SYMBOL INDEX (3195 symbols across 377 files)

FILE: example/demo.cpp
  class gps_position (line 46) | class gps_position
    method serialize (line 54) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method gps_position (line 59) | gps_position(){}
    method gps_position (line 60) | gps_position(int _d, int _m, float _s) :
  class bus_stop (line 75) | class bus_stop
    method serialize (line 83) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop (line 89) | bus_stop(const gps_position & _lat, const gps_position & _long) :
    method bus_stop (line 93) | bus_stop(){}
  class bus_stop_corner (line 109) | class bus_stop_corner : public bus_stop
    method description (line 114) | virtual std::string description() const
    method serialize (line 119) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop_corner (line 127) | bus_stop_corner(){}
    method bus_stop_corner (line 128) | bus_stop_corner(const gps_position & _lat, const gps_position & _long,
  class bus_stop_destination (line 136) | class bus_stop_destination : public bus_stop
    method description (line 140) | virtual std::string description() const
    method serialize (line 145) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop_destination (line 151) | bus_stop_destination(){}
    method bus_stop_destination (line 152) | bus_stop_destination(
  class bus_route (line 172) | class bus_route
    method serialize (line 179) | void serialize(Archive &ar, const unsigned int version)
    method bus_route (line 193) | bus_route(){}
    method append (line 194) | void append(bus_stop *_bs)
  class bus_schedule (line 222) | class bus_schedule
    type trip_info (line 227) | struct trip_info
      method serialize (line 230) | void serialize(Archive &ar, const unsigned int file_version)
      method trip_info (line 246) | trip_info(){}
      method trip_info (line 247) | trip_info(int _h, int _m, const std::string &_d) :
    method serialize (line 257) | void serialize(Archive &ar, const unsigned int version)
    method append (line 262) | void append(const std::string &_d, int _h, int _m, bus_route *_br)
    method bus_schedule (line 266) | bus_schedule(){}
  function save_schedule (line 283) | void save_schedule(const bus_schedule &s, const char * filename){
  function restore_schedule (line 290) | void
  function main (line 301) | int main(int argc, char *argv[])

FILE: example/demo_auto_ptr.cpp
  type std (line 17) | namespace std{
  type boost (line 28) | namespace boost {
    type serialization (line 29) | namespace serialization {
      function save (line 36) | inline void save(
      function load (line 48) | inline void load(
      function serialize (line 67) | inline void serialize(
  class A (line 80) | class A
    method serialize (line 86) | void serialize(Archive &ar, const unsigned int /* file_version */){
    method A (line 90) | A(){}
  function save (line 94) | void save(const std::auto_ptr<A> & spa, const char *filename)
  function load (line 101) | void load(std::auto_ptr<A> & spa, const char *filename)
  function main (line 111) | int main(int argc, char *argv[])

FILE: example/demo_dll_a.hpp
  type std (line 27) | namespace std{
  function randomize (line 140) | void randomize(S &x)
  function accumulate (line 152) | void accumulate(std::size_t & s, const T & t){
  type h (line 190) | enum h

FILE: example/demo_dll_b.hpp
  type std (line 24) | namespace std{
  class B (line 37) | class B : public A
    method save (line 42) | void save(Archive &ar, const unsigned int /* file_version */) const
    method load (line 57) | void load(Archive & ar, const unsigned int file_version)

FILE: example/demo_exception.cpp
  type std (line 29) | namespace std{
  type deleter (line 47) | struct deleter
  class Course (line 54) | class Course
    method Course (line 83) | Course(){
    method serialize (line 96) | void serialize(Archive & ar, const unsigned int /* file_version */){
  class Student (line 55) | class Student
    method Student (line 61) | Student(){
    method serialize (line 72) | void serialize(Archive & ar, const unsigned int /* file_version */){
  class Student (line 57) | class Student
    method Student (line 61) | Student(){
    method serialize (line 72) | void serialize(Archive & ar, const unsigned int /* file_version */){
  class Course (line 79) | class Course
    method Course (line 83) | Course(){
    method serialize (line 96) | void serialize(Archive & ar, const unsigned int /* file_version */){
  class School (line 103) | class School
  function init (line 177) | void init(School *school){
  function save (line 217) | void save(const School * const school, const char *filename){
  function load (line 223) | void load(School * & school, const char *filename){
  function main (line 235) | int main(int argc, char *argv[]){

FILE: example/demo_fast_archive.cpp
  class fast_binary_oarchive (line 31) | class fast_binary_oarchive :
    method save_override (line 63) | void save_override(T & t){
    method save_override (line 70) | void save_override(const int (& t)[N]){
    method save_override (line 74) | void save_override(const unsigned int (& t)[N]){
    method save_override (line 78) | void save_override(const long (& t)[N]){
    method save_override (line 82) | void save_override(const unsigned long (& t)[N]){
    method fast_binary_oarchive (line 86) | fast_binary_oarchive(std::ostream & os, unsigned flags = 0) :
    method fast_binary_oarchive (line 89) | fast_binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
  class fast_binary_iarchive (line 99) | class fast_binary_iarchive :
    method load_override (line 131) | void load_override(T & t){
    method load_override (line 136) | void load_override(int (& t)[N]){
    method load_override (line 140) | void load_override(unsigned int (& t)[N]){
    method load_override (line 144) | void load_override(long (& t)[N]){
    method load_override (line 148) | void load_override(unsigned long (& t)[N]){
    method fast_binary_iarchive (line 152) | fast_binary_iarchive(std::istream & is, unsigned int flags = 0) :
    method fast_binary_iarchive (line 155) | fast_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
  function main (line 163) | int main( int argc, char* argv[] )

FILE: example/demo_gps.hpp
  class gps_position (line 35) | class gps_position
    method serialize (line 45) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method gps_position (line 53) | gps_position(){}
    method gps_position (line 54) | gps_position(int _d, int _m, float _s) :
  class bus_stop (line 70) | class bus_stop
    method serialize (line 78) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop (line 85) | bus_stop(const gps_position & _lat, const gps_position & _long) :
    method bus_stop (line 89) | bus_stop(){}
  class bus_stop_corner (line 106) | class bus_stop_corner : public bus_stop
    method description (line 111) | virtual std::string description() const
    method serialize (line 116) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop_corner (line 124) | bus_stop_corner(){}
    method bus_stop_corner (line 125) | bus_stop_corner(const gps_position & _lat, const gps_position & _long,
  class bus_stop_destination (line 133) | class bus_stop_destination : public bus_stop
    method description (line 137) | virtual std::string description() const
    method serialize (line 142) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop_destination (line 148) | bus_stop_destination(){}
    method bus_stop_destination (line 149) | bus_stop_destination(
  class bus_route (line 169) | class bus_route
    method serialize (line 176) | void serialize(Archive &ar, const unsigned int version)
    method bus_route (line 190) | bus_route(){}
    method append (line 191) | void append(bus_stop *_bs)
  class bus_schedule (line 218) | class bus_schedule
    method serialize (line 223) | void serialize(Archive &ar, const unsigned int version)
    type trip_info (line 230) | struct trip_info
      method serialize (line 233) | void serialize(Archive &ar, const unsigned int file_version)
      method trip_info (line 250) | trip_info(){}
      method trip_info (line 251) | trip_info(int _h, int _m, const std::string &_d) :
    method append (line 261) | void append(const std::string &_d, int _h, int _m, bus_route *_br)
    method bus_schedule (line 265) | bus_schedule(){}

FILE: example/demo_log.cpp
  function main (line 16) | int main(int argc, char *argv[]){

FILE: example/demo_pimpl.cpp
  function main (line 18) | int main(int argc, char* argv[])

FILE: example/demo_pimpl_A.cpp
  type B (line 15) | struct B {
    method serialize (line 18) | void serialize(Archive & ar, const unsigned int /* file_version */){

FILE: example/demo_pimpl_A.hpp
  type B (line 13) | struct B
  type A (line 15) | struct A {

FILE: example/demo_polymorphic.cpp
  function main (line 21) | int main(int argc, char* argv[])

FILE: example/demo_polymorphic_A.hpp
  type boost (line 12) | namespace boost {
    type archive (line 13) | namespace archive {
      class polymorphic_iarchive (line 15) | class polymorphic_iarchive
      class polymorphic_oarchive (line 16) | class polymorphic_oarchive
  type A (line 21) | struct A {
    method serialize (line 24) | void serialize(
    method A (line 34) | A() :

FILE: example/demo_portable_archive.cpp
  type std (line 23) | namespace std{ using ::rand; }
  class A (line 26) | class A
    method serialize (line 37) | void serialize(Archive & ar, const unsigned int /* version */){
    method A (line 51) | A() :
  function main (line 62) | int main( int /* argc */, char* /* argv */[] )

FILE: example/demo_shared_ptr.cpp
  type std (line 21) | namespace std{
  class A (line 34) | class A
    method serialize (line 40) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method A (line 45) | A(){++count;}
  class B (line 53) | class B : public A
    method serialize (line 59) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method B (line 64) | B() : A() {}
  function display (line 74) | void display(boost::shared_ptr<A> &spa, boost::shared_ptr<A> &spa1)
  function main (line 85) | int main(int /* argc */, char * /*argv*/[])

FILE: example/demo_simple_log.cpp
  function main (line 16) | int main(int argc, char *argv[])

FILE: example/demo_trivial_archive.cpp
  class trivial_oarchive (line 15) | class trivial_oarchive {
    method register_type (line 23) | void register_type(){}
    method trivial_oarchive (line 24) | trivial_oarchive & operator<<(const T & t){
    method trivial_oarchive (line 27) | trivial_oarchive & operator&(const T & t){
  function main (line 35) | int main(int argc, char *argv[])

FILE: example/demo_xml.cpp
  type std (line 18) | namespace std{
  function save_schedule (line 29) | void save_schedule(const bus_schedule &s, const char * filename){
  function restore_schedule (line 37) | void
  function main (line 49) | int main(int argc, char *argv[])

FILE: example/demo_xml.hpp
  class gps_position (line 35) | class gps_position
    method serialize (line 45) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method gps_position (line 53) | gps_position(){}
    method gps_position (line 54) | gps_position(int _d, int _m, float _s) :
  class bus_stop (line 70) | class bus_stop
    method serialize (line 78) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop (line 85) | bus_stop(const gps_position & _lat, const gps_position & _long) :
    method bus_stop (line 89) | bus_stop(){}
  class bus_stop_corner (line 106) | class bus_stop_corner : public bus_stop
    method description (line 111) | virtual std::string description() const
    method serialize (line 116) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop_corner (line 124) | bus_stop_corner(){}
    method bus_stop_corner (line 125) | bus_stop_corner(const gps_position & _lat, const gps_position & _long,
  class bus_stop_destination (line 133) | class bus_stop_destination : public bus_stop
    method description (line 137) | virtual std::string description() const
    method serialize (line 142) | void serialize(Archive &ar, const unsigned int version)
    method bus_stop_destination (line 148) | bus_stop_destination(){}
    method bus_stop_destination (line 149) | bus_stop_destination(
  class bus_route (line 169) | class bus_route
    method serialize (line 176) | void serialize(Archive &ar, const unsigned int version)
    method bus_route (line 190) | bus_route(){}
    method append (line 191) | void append(bus_stop *_bs)
  class bus_schedule (line 218) | class bus_schedule
    method serialize (line 223) | void serialize(Archive &ar, const unsigned int version)
    type trip_info (line 230) | struct trip_info
      method serialize (line 233) | void serialize(Archive &ar, const unsigned int file_version)
      method trip_info (line 250) | trip_info(){}
      method trip_info (line 251) | trip_info(int _h, int _m, const std::string &_d) :
    method append (line 261) | void append(const std::string &_d, int _h, int _m, bus_route *_br)
    method bus_schedule (line 265) | bus_schedule(){}

FILE: example/demo_xml_load.cpp
  function restore_schedule (line 18) | void
  function main (line 30) | int main(int argc, char *argv[])

FILE: example/demo_xml_save.cpp
  function save_schedule (line 18) | void save_schedule(const bus_schedule &s, const char * filename){
  function main (line 26) | int main(int argc, char *argv[])

FILE: example/fix_six.cpp
  function usage (line 7) | void usage(const char * program_name){
  function main (line 12) | int main(int argc, char *argv[]){

FILE: example/log_archive.cpp
  type boost (line 24) | namespace boost {
    type archive (line 25) | namespace archive {
      class detail::archive_serializer_map<log_archive> (line 27) | class detail::archive_serializer_map<log_archive>
      class basic_xml_oarchive<log_archive> (line 28) | class basic_xml_oarchive<log_archive>
      class xml_oarchive_impl<log_archive> (line 29) | class xml_oarchive_impl<log_archive>

FILE: example/log_archive.hpp
  type boost (line 21) | namespace boost {
    type archive (line 22) | namespace archive {
      type detail (line 23) | namespace detail {
        class interface_oarchive (line 24) | class interface_oarchive
  class log_archive (line 33) | class log_archive :
    method save_override (line 49) | void save_override(T & t){
    method save_override (line 56) | void save_override(const boost::serialization::nvp< T > & t){
    method save_override (line 64) | void save_override(const boost::archive::object_id_type & t){}
    method save_override (line 65) | void save_override(const boost::archive::object_reference_type & t){}
    method save_override (line 66) | void save_override(const boost::archive::version_type & t){}
    method save_override (line 67) | void save_override(const boost::archive::class_id_type & t){}
    method save_override (line 68) | void save_override(const boost::archive::class_id_optional_type & t){}
    method save_override (line 69) | void save_override(const boost::archive::class_id_reference_type & t){}
    method save_override (line 70) | void save_override(const boost::archive::class_name_type & t){}
    method save_override (line 71) | void save_override(const boost::archive::tracking_type & t){}
    method log_archive (line 73) | log_archive(std::ostream & os, unsigned int flags = 0) :

FILE: example/polymorphic_portable_binary_iarchive.cpp
  type boost (line 21) | namespace boost {
    type archive (line 22) | namespace archive {
      class binary_iarchive_impl<
    polymorphic_portable_binary_iarchive,
    std::istream::char_type,
    std::istream::traits_type
> (line 24) | class binary_iarchive_impl<
      class detail::archive_pointer_iserializer<
    polymorphic_portable_binary_iarchive
> (line 29) | class detail::archive_pointer_iserializer<

FILE: example/polymorphic_portable_binary_oarchive.cpp
  type boost (line 21) | namespace boost {
    type archive (line 22) | namespace archive {
      class binary_oarchive_impl<
    polymorphic_portable_binary_oarchive,
    std::ostream::char_type,
    std::ostream::traits_type
> (line 25) | class binary_oarchive_impl<
      class detail::archive_pointer_oserializer<
    polymorphic_portable_binary_oarchive
> (line 30) | class detail::archive_pointer_oserializer<

FILE: example/portable_binary_archive.hpp
  type portable_binary_archive_flags (line 26) | enum portable_binary_archive_flags {
  function reverse_bytes (line 35) | inline void

FILE: example/portable_binary_iarchive.cpp
  type boost (line 117) | namespace boost {
    type archive (line 118) | namespace archive {
      type detail (line 120) | namespace detail {
        class archive_serializer_map<portable_binary_iarchive> (line 121) | class archive_serializer_map<portable_binary_iarchive>
      class basic_binary_iprimitive<
    portable_binary_iarchive,
    std::istream::char_type,
    std::istream::traits_type
> (line 124) | class basic_binary_iprimitive<

FILE: example/portable_binary_iarchive.hpp
  class portable_binary_iarchive_exception (line 37) | class portable_binary_iarchive_exception :
    type exception_code (line 41) | enum exception_code {
    method portable_binary_iarchive_exception (line 44) | portable_binary_iarchive_exception(exception_code c = incompatible_int...
  class portable_binary_iarchive (line 68) | class portable_binary_iarchive :
    method load (line 102) | void load(T & t){
    method load (line 109) | void load(boost::serialization::item_version_type & t){
    method load (line 115) | void load(boost::archive::version_type & t){
    method load (line 121) | void load(boost::archive::class_id_type & t){
    method load (line 127) | void load(std::string & t){
    method load (line 131) | void load(std::wstring & t){
    method load (line 135) | void load(float & t){
    method load (line 140) | void load(double & t){
    method load (line 145) | void load(char & t){
    method load (line 148) | void load(unsigned char & t){
    method load_override (line 154) | void load_override(T & t){
    method load_override (line 159) | void load_override(boost::archive::class_id_optional_type &){}
    method portable_binary_iarchive (line 163) | portable_binary_iarchive(std::istream & is, unsigned flags = 0) :
    method portable_binary_iarchive (line 174) | portable_binary_iarchive(

FILE: example/portable_binary_oarchive.cpp
  type boost (line 84) | namespace boost {
    type archive (line 85) | namespace archive {
      type detail (line 87) | namespace detail {
        class archive_serializer_map<portable_binary_oarchive> (line 88) | class archive_serializer_map<portable_binary_oarchive>
      class basic_binary_oprimitive<
    portable_binary_oarchive,
    std::ostream::char_type,
    std::ostream::traits_type
> (line 91) | class basic_binary_oprimitive<

FILE: example/portable_binary_oarchive.hpp
  class portable_binary_oarchive_exception (line 36) | class portable_binary_oarchive_exception :
    method portable_binary_oarchive_exception (line 43) | portable_binary_oarchive_exception(exception_code c = invalid_flags )
  class portable_binary_oarchive (line 63) | class portable_binary_oarchive :
    method save (line 101) | void save(const T & t){
    method save (line 104) | void save(const std::string & t){
    method save (line 108) | void save(const std::wstring & t){
    method save (line 112) | void save(const float & t){
    method save (line 117) | void save(const double & t){
    method save (line 122) | void save(const char & t){
    method save (line 125) | void save(const unsigned char & t){
    method save_override (line 134) | void save_override(T & t){
    method save_override (line 138) | void save_override(const boost::archive::class_name_type & t){
    method save_override (line 143) | void save_override(
    method portable_binary_oarchive (line 149) | portable_binary_oarchive(std::ostream & os, unsigned flags = 0) :
    method portable_binary_oarchive (line 160) | portable_binary_oarchive(

FILE: example/simple_log_archive.hpp
  type std (line 24) | namespace std{
  class simple_log_archive (line 43) | class simple_log_archive {
    type save_enum_type (line 48) | struct save_enum_type {
      method invoke (line 50) | static void invoke(Archive &ar, const T &t){
    type save_primitive (line 55) | struct save_primitive {
      method invoke (line 57) | static void invoke(Archive & ar, const T & t){
    type save_only (line 62) | struct save_only {
      method invoke (line 64) | static void invoke(Archive & ar, const T & t){
    method save (line 75) | void save(const T &t){
    method save (line 93) | void save(const std::wstring &ws){
    method register_type (line 107) | void register_type(const T * = NULL){}
    method get_library_version (line 109) | unsigned int get_library_version(){
    method save_binary (line 113) | void
    method simple_log_archive (line 120) | simple_log_archive & operator<<(T const & t){
    method simple_log_archive (line 126) | simple_log_archive & operator<<(T * const t){
    method simple_log_archive (line 135) | simple_log_archive & operator<<(const T (&t)[N]){
    method simple_log_archive (line 142) | simple_log_archive & operator<<(const boost::serialization::nvp< T > &...
    method simple_log_archive (line 156) | simple_log_archive & operator&(const T & t){
    method simple_log_archive (line 161) | simple_log_archive(std::ostream & os) :

FILE: include/boost/archive/archive_exception.hpp
  type boost (line 36) | namespace boost {
    type archive (line 37) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 42) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/basic_archive.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class version_type (line 42) | class version_type {
        method version_type (line 48) | version_type(): t(0) {}
        method version_type (line 49) | explicit version_type(const unsigned int & t_) : t(t_){
        method version_type (line 52) | version_type(const version_type & t_) :
        method version_type (line 55) | version_type & operator=(const version_type & rhs){
      class class_id_type (line 75) | class class_id_type {
        method class_id_type (line 81) | class_id_type() : t(0) {}
        method class_id_type (line 82) | explicit class_id_type(const int t_) : t(t_){
        method class_id_type (line 85) | explicit class_id_type(const std::size_t t_) : t(t_){
        method class_id_type (line 88) | class_id_type(const class_id_type & t_) :
        method class_id_type (line 91) | class_id_type & operator=(const class_id_type & rhs){
      class object_id_type (line 114) | class object_id_type {
        method object_id_type (line 119) | object_id_type(): t(0) {}
        method object_id_type (line 122) | explicit object_id_type(const std::size_t & t_) : t(static_cast<ba...
        method object_id_type (line 127) | object_id_type(const object_id_type & t_) :
        method object_id_type (line 130) | object_id_type & operator=(const object_id_type & rhs){
      type tracking_type (line 154) | struct tracking_type {
        method tracking_type (line 156) | explicit tracking_type(const bool t_ = false)
        method tracking_type (line 159) | tracking_type(const tracking_type & t_)
        method tracking_type (line 168) | tracking_type & operator=(const bool t_){
        method tracking_type (line 178) | tracking_type & operator=(const tracking_type & rhs){
      type class_name_type (line 184) | struct class_name_type :
        method size (line 194) | std::size_t size() const {
        method class_name_type (line 197) | explicit class_name_type(const char *key_)
        method class_name_type (line 199) | explicit class_name_type(char *key_)
        method class_name_type (line 201) | class_name_type & operator=(const class_name_type & rhs){
      type archive_flags (line 207) | enum archive_flags {

FILE: include/boost/archive/basic_binary_iarchive.hpp
  type boost (line 44) | namespace boost {
    type archive (line 45) | namespace archive {
      type detail (line 47) | namespace detail {
        class interface_iarchive (line 48) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 54) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 75) | void load_override(T & t){
      function load_override (line 89) | void load_override(class_id_optional_type & /* t */){}
      function load_override (line 91) | void load_override(tracking_type & t, int /*version*/){
      function load_override (line 104) | void load_override(class_id_type & t){
      function load_override (line 133) | void load_override(class_id_reference_type & t){
      function load_override (line 137) | void load_override(version_type & t){
      function load_override (line 168) | void load_override(boost::serialization::item_version_type & t){
      function load_override (line 187) | void load_override(serialization::collection_size_type & t){
      function basic_binary_iarchive (line 203) | basic_binary_iarchive(unsigned int flags) :

FILE: include/boost/archive/basic_binary_iprimitive.hpp
  type std (line 40) | namespace std{
  type archive (line 61) | namespace archive {
    function basic_binary_iprimitive (line 66) | class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {

FILE: include/boost/archive/basic_binary_oarchive.hpp
  type boost (line 45) | namespace boost {
    type archive (line 46) | namespace archive {
      type detail (line 48) | namespace detail {
        class interface_oarchive (line 49) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 61) | class BOOST_SYMBOL_VISIBLE
      function save_override (line 79) | void save_override(const T & t){
      function save_override (line 94) | void save_override(const class_id_optional_type & /* t */){}
      function save_override (line 98) | void save_override(const boost::archive::version_type & t){
      function save_override (line 113) | void save_override(const boost::serialization::item_version_type & t){
      function save_override (line 129) | void save_override(class_id_type & t){
      function save_override (line 144) | void save_override(class_id_reference_type & t){
      function save_override (line 151) | void save_override(const class_name_type & t){
      function save_override (line 157) | void save_override(const serialization::collection_size_type & t){
      function basic_binary_oarchive (line 171) | basic_binary_oarchive(unsigned int flags) :

FILE: include/boost/archive/basic_binary_oprimitive.hpp
  type std (line 35) | namespace std{
  type boost (line 55) | namespace boost {
    type archive (line 56) | namespace archive {
      function basic_binary_oprimitive (line 62) | class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {

FILE: include/boost/archive/basic_streambuf_locale_saver.hpp
  type boost (line 41) | namespace boost{
    type archive (line 42) | namespace archive{
      class basic_streambuf_locale_saver (line 45) | class basic_streambuf_locale_saver :
        method basic_streambuf_locale_saver (line 49) | explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr>...
      class basic_istream_locale_saver (line 63) | class basic_istream_locale_saver :
        method basic_istream_locale_saver (line 67) | explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
      class basic_ostream_locale_saver (line 82) | class basic_ostream_locale_saver :
        method basic_ostream_locale_saver (line 86) | explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :

FILE: include/boost/archive/basic_text_iarchive.hpp
  type boost (line 39) | namespace boost {
    type archive (line 40) | namespace archive {
      type detail (line 42) | namespace detail {
        class interface_iarchive (line 43) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 49) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 69) | void load_override(T & t){
      function load_override (line 73) | void load_override(class_id_optional_type & /*t*/){}
      function basic_text_iarchive (line 81) | basic_text_iarchive(unsigned int flags) :

FILE: include/boost/archive/basic_text_iprimitive.hpp
  type std (line 32) | namespace std{
  type boost (line 53) | namespace boost {
    type archive (line 54) | namespace archive {
      function basic_text_iprimitive (line 64) | class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {

FILE: include/boost/archive/basic_text_oarchive.hpp
  type boost (line 39) | namespace boost {
    type archive (line 40) | namespace archive {
      type detail (line 42) | namespace detail {
        class interface_oarchive (line 43) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 49) | class BOOST_SYMBOL_VISIBLE
      function newline (line 74) | void newline(){
      function save_override (line 82) | void save_override(T & t){
      function save_override (line 87) | void save_override(const object_id_type & t){
      function save_override (line 93) | void save_override(const class_id_optional_type & /* t */){}
      function save_override (line 95) | void save_override(const class_name_type & t){
      function basic_text_oarchive (line 103) | basic_text_oarchive(unsigned int flags) :

FILE: include/boost/archive/basic_text_oprimitive.hpp
  type std (line 41) | namespace std{
  type boost (line 60) | namespace boost {
    type archive (line 61) | namespace archive {
      function basic_text_oprimitive (line 66) | class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
      function put (line 198) | void put(const char * s){

FILE: include/boost/archive/basic_xml_archive.hpp
  type boost (line 24) | namespace boost {
    type archive (line 25) | namespace archive {

FILE: include/boost/archive/basic_xml_iarchive.hpp
  type boost (line 33) | namespace boost {
    type archive (line 34) | namespace archive {
      type detail (line 36) | namespace detail {
        class interface_iarchive (line 37) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 61) | void load_override(T & t)
      function load_override (line 74) | void load_override(
      function load_override (line 92) | void load_override(class_id_optional_type & /* t */){}

FILE: include/boost/archive/basic_xml_oarchive.hpp
  type boost (line 33) | namespace boost {
    type archive (line 34) | namespace archive {
      type detail (line 36) | namespace detail {
        class interface_oarchive (line 37) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
      function save_override (line 84) | void save_override(T & t)
      function save_override (line 96) | void save_override(

FILE: include/boost/archive/binary_iarchive.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 34) | class BOOST_SYMBOL_VISIBLE
      function binary_iarchive (line 48) | binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :

FILE: include/boost/archive/binary_iarchive_impl.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      type detail (line 31) | namespace detail {
        class interface_iarchive (line 32) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 36) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 57) | void load_override(T & t){
      function init (line 60) | void init(unsigned int flags){
      function binary_iarchive_impl (line 72) | binary_iarchive_impl(
      function binary_iarchive_impl (line 82) | binary_iarchive_impl(

FILE: include/boost/archive/binary_oarchive.hpp
  type boost (line 29) | namespace boost {
    type archive (line 30) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 35) | class BOOST_SYMBOL_VISIBLE
      function binary_oarchive (line 48) | binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :

FILE: include/boost/archive/binary_oarchive_impl.hpp
  type boost (line 29) | namespace boost {
    type archive (line 30) | namespace archive {
      type detail (line 32) | namespace detail {
        class interface_oarchive (line 33) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 37) | class BOOST_SYMBOL_VISIBLE
      function save_override (line 58) | void save_override(T & t){
      function init (line 61) | void init(unsigned int flags) {
      function binary_oarchive_impl (line 73) | binary_oarchive_impl(
      function binary_oarchive_impl (line 83) | binary_oarchive_impl(

FILE: include/boost/archive/binary_wiarchive.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class binary_wiarchive (line 31) | class binary_wiarchive :
        method binary_wiarchive (line 37) | binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
        method binary_wiarchive (line 42) | binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :

FILE: include/boost/archive/binary_woarchive.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class binary_woarchive (line 34) | class binary_woarchive :
        method binary_woarchive (line 40) | binary_woarchive(std::wostream & os, unsigned int flags = 0) :
        method binary_woarchive (line 45) | binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :

FILE: include/boost/archive/codecvt_null.hpp
  type std (line 30) | namespace std {
  type boost (line 46) | namespace boost {
    type archive (line 47) | namespace archive {
      class codecvt_null (line 50) | class codecvt_null
      class codecvt_null<char> (line 53) | class codecvt_null<char> : public std::codecvt<char, char, std::mbst...
        method BOOST_NOEXCEPT_OR_NOTHROW (line 55) | BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
        method codecvt_null (line 59) | explicit codecvt_null(std::size_t no_locale_manage = 0) :
      class BOOST_SYMBOL_VISIBLE (line 66) | class BOOST_SYMBOL_VISIBLE
      function BOOST_SYMBOL_EXPORT (line 91) | BOOST_SYMBOL_EXPORT int do_encoding( ) const BOOST_NOEXCEPT_OR_NOTHR...
      function BOOST_SYMBOL_EXPORT (line 95) | BOOST_SYMBOL_EXPORT bool do_always_noconv() const BOOST_NOEXCEPT_OR_...
      function BOOST_SYMBOL_EXPORT (line 99) | BOOST_SYMBOL_EXPORT int do_max_length( ) const BOOST_NOEXCEPT_OR_NOT...

FILE: include/boost/archive/detail/archive_serializer_map.hpp
  type boost (line 27) | namespace boost {
    type serialization (line 29) | namespace serialization {
      class extended_type_info (line 30) | class extended_type_info
    type archive (line 33) | namespace archive {
      type detail (line 34) | namespace detail {
        class basic_serializer (line 36) | class basic_serializer
        function archive_serializer_map (line 39) | class BOOST_SYMBOL_VISIBLE archive_serializer_map {

FILE: include/boost/archive/detail/basic_iarchive.hpp
  type boost (line 31) | namespace boost {
    type serialization (line 32) | namespace serialization {
      class extended_type_info (line 33) | class extended_type_info
    type archive (line 36) | namespace archive {
      type detail (line 37) | namespace detail {
        class basic_iarchive_impl (line 39) | class basic_iarchive_impl
        class basic_iserializer (line 40) | class basic_iserializer
        class basic_pointer_iserializer (line 41) | class basic_pointer_iserializer
        class BOOST_SYMBOL_VISIBLE (line 45) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/detail/basic_iserializer.hpp
  type boost (line 33) | namespace boost {
    type serialization (line 34) | namespace serialization {
      class extended_type_info (line 35) | class extended_type_info
    type archive (line 39) | namespace archive {
      type detail (line 40) | namespace detail {
        class basic_iarchive (line 42) | class basic_iarchive
        class basic_pointer_iserializer (line 43) | class basic_pointer_iserializer
        function basic_iserializer (line 45) | class BOOST_SYMBOL_VISIBLE basic_iserializer :
        function set_bpis (line 59) | void set_bpis(basic_pointer_iserializer *bpis){
        function basic_pointer_iserializer (line 62) | const basic_pointer_iserializer * get_bpis_ptr() const {

FILE: include/boost/archive/detail/basic_oarchive.hpp
  type boost (line 29) | namespace boost {
    type serialization (line 30) | namespace serialization {
      class extended_type_info (line 31) | class extended_type_info
    type archive (line 34) | namespace archive {
      type detail (line 35) | namespace detail {
        class basic_oarchive_impl (line 37) | class basic_oarchive_impl
        class basic_oserializer (line 38) | class basic_oserializer
        class basic_pointer_oserializer (line 39) | class basic_pointer_oserializer
        class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
        function save_null_pointer (line 79) | void save_null_pointer(){

FILE: include/boost/archive/detail/basic_oserializer.hpp
  type boost (line 34) | namespace boost {
    type serialization (line 35) | namespace serialization {
      class extended_type_info (line 36) | class extended_type_info
    type archive (line 40) | namespace archive {
      type detail (line 41) | namespace detail {
        class basic_oarchive (line 43) | class basic_oarchive
        class basic_pointer_oserializer (line 44) | class basic_pointer_oserializer
        function basic_oserializer (line 46) | class BOOST_SYMBOL_VISIBLE basic_oserializer :
        function set_bpos (line 60) | void set_bpos(basic_pointer_oserializer *bpos){
        function basic_pointer_oserializer (line 63) | const basic_pointer_oserializer * get_bpos() const {

FILE: include/boost/archive/detail/basic_pointer_iserializer.hpp
  type boost (line 31) | namespace boost {
    type serialization (line 32) | namespace serialization {
      class extended_type_info (line 33) | class extended_type_info
    type archive (line 37) | namespace archive {
      type detail (line 38) | namespace detail {
        class basic_iarchive (line 40) | class basic_iarchive
        class basic_iserializer (line 41) | class basic_iserializer
        function basic_pointer_iserializer (line 43) | class BOOST_SYMBOL_VISIBLE basic_pointer_iserializer

FILE: include/boost/archive/detail/basic_pointer_oserializer.hpp
  type boost (line 31) | namespace boost {
    type serialization (line 32) | namespace serialization {
      class extended_type_info (line 33) | class extended_type_info
    type archive (line 36) | namespace archive {
      type detail (line 37) | namespace detail {
        class basic_oarchive (line 39) | class basic_oarchive
        class basic_oserializer (line 40) | class basic_oserializer
        function basic_pointer_oserializer (line 42) | class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer :

FILE: include/boost/archive/detail/basic_serializer.hpp
  type boost (line 31) | namespace boost {
    type archive (line 32) | namespace archive {
      type detail (line 33) | namespace detail {
        class basic_serializer (line 35) | class basic_serializer :
          method basic_serializer (line 40) | explicit basic_serializer(
        class basic_serializer_arg (line 62) | class basic_serializer_arg : public basic_serializer {
          method basic_serializer_arg (line 64) | basic_serializer_arg(const serialization::extended_type_info & e...

FILE: include/boost/archive/detail/basic_serializer_map.hpp
  type boost (line 27) | namespace boost {
    type serialization (line 28) | namespace serialization {
      class extended_type_info (line 29) | class extended_type_info
    type archive (line 32) | namespace archive {
      type detail (line 33) | namespace detail {
        class basic_serializer (line 35) | class basic_serializer
        class BOOST_SYMBOL_VISIBLE (line 37) | class BOOST_SYMBOL_VISIBLE
        type type_info_pointer_compare (line 41) | struct type_info_pointer_compare

FILE: include/boost/archive/detail/check.hpp
  type boost (line 46) | namespace boost {
    type archive (line 47) | namespace archive {
      type detail (line 48) | namespace detail {
        function check_object_level (line 53) | inline void check_object_level(){
        function check_object_versioning (line 66) | inline void check_object_versioning(){
        function check_object_tracking (line 84) | inline void check_object_tracking(){
        function check_pointer_level (line 106) | inline void check_pointer_level(){
        function check_pointer_tracking (line 143) | void inline check_pointer_tracking(){
        function check_const_loading (line 154) | inline void check_const_loading(){

FILE: include/boost/archive/detail/common_iarchive.hpp
  type boost (line 30) | namespace boost {
    type archive (line 31) | namespace archive {
      type detail (line 32) | namespace detail {
        class extended_type_info (line 34) | class extended_type_info
        class BOOST_SYMBOL_VISIBLE (line 38) | class BOOST_SYMBOL_VISIBLE
      function vload (line 48) | void vload(object_id_type & t) BOOST_OVERRIDE {
      function vload (line 51) | void vload(class_id_type & t) BOOST_OVERRIDE {
      function vload (line 54) | void vload(class_id_optional_type & t) BOOST_OVERRIDE {
      function vload (line 57) | void vload(tracking_type & t) BOOST_OVERRIDE {
      function vload (line 60) | void vload(class_name_type &s) BOOST_OVERRIDE {
      function load_override (line 63) | protected:
      function load_start (line 71) | void load_start(const char * /*name*/){}
      function load_end (line 72) | void load_end(const char * /*name*/){}
      function common_iarchive (line 74) | common_iarchive(unsigned int flags = 0) :

FILE: include/boost/archive/detail/common_oarchive.hpp
  type boost (line 29) | namespace boost {
    type archive (line 30) | namespace archive {
      type detail (line 31) | namespace detail {
        class BOOST_SYMBOL_VISIBLE (line 36) | class BOOST_SYMBOL_VISIBLE
      function vsave (line 46) | void vsave(const object_id_type t) BOOST_OVERRIDE {
      function vsave (line 49) | void vsave(const object_reference_type t) BOOST_OVERRIDE {
      function vsave (line 52) | void vsave(const class_id_type t) BOOST_OVERRIDE {
      function vsave (line 55) | void vsave(const class_id_reference_type t) BOOST_OVERRIDE {
      function vsave (line 58) | void vsave(const class_id_optional_type t) BOOST_OVERRIDE {
      function vsave (line 61) | void vsave(const class_name_type & t) BOOST_OVERRIDE {
      function vsave (line 64) | void vsave(const tracking_type t) BOOST_OVERRIDE {
      function save_override (line 67) | protected:
      function save_start (line 73) | void save_start(const char * /*name*/){}
      function save_end (line 74) | void save_end(const char * /*name*/){}
      function common_oarchive (line 75) | common_oarchive(unsigned int flags = 0) :

FILE: include/boost/archive/detail/helper_collection.hpp
  type boost (line 30) | namespace boost {
    type archive (line 32) | namespace archive {
      type detail (line 33) | namespace detail {
        class helper_collection (line 35) | class helper_collection
          method make_helper_ptr (line 48) | boost::shared_ptr<void> make_helper_ptr(){
          type predicate (line 57) | struct predicate {
            method BOOST_DEFAULTED_FUNCTION (line 58) | BOOST_DEFAULTED_FUNCTION(predicate(const predicate& rhs), : m_...
            method predicate (line 65) | predicate(const void * ti) :
          method helper_collection (line 70) | helper_collection(){}
          method Helper (line 74) | Helper& find_helper(void * const id = 0) {

FILE: include/boost/archive/detail/interface_iarchive.hpp
  type boost (line 27) | namespace boost {
    type archive (line 28) | namespace archive {
      type detail (line 29) | namespace detail {
        class basic_pointer_iserializer (line 31) | class basic_pointer_iserializer
        class interface_iarchive (line 34) | class interface_iarchive
          method interface_iarchive (line 37) | interface_iarchive() {}
          method Archive (line 45) | Archive * This(){
          method basic_pointer_iserializer (line 50) | const basic_pointer_iserializer *
          method Helper (line 60) | Helper &
          method Archive (line 67) | Archive & operator>>(T & t){
          method Archive (line 74) | Archive & operator&(T & t){

FILE: include/boost/archive/detail/interface_oarchive.hpp
  type boost (line 29) | namespace boost {
    type archive (line 30) | namespace archive {
      type detail (line 31) | namespace detail {
        class basic_pointer_oserializer (line 33) | class basic_pointer_oserializer
        class interface_oarchive (line 36) | class interface_oarchive
          method interface_oarchive (line 39) | interface_oarchive() {}
          method Archive (line 47) | Archive * This(){
          method basic_pointer_oserializer (line 52) | const basic_pointer_oserializer *
          method Helper (line 63) | Helper &
          method Archive (line 70) | Archive & operator<<(const T & t){
          method Archive (line 77) | Archive & operator&(const T & t){

FILE: include/boost/archive/detail/iserializer.hpp
  type std (line 33) | namespace std{
  type boost (line 96) | namespace boost {
    type serialization (line 98) | namespace serialization {
      class extended_type_info (line 99) | class extended_type_info
    type archive (line 102) | namespace archive {
      class load_access (line 106) | class load_access {
        method load_primitive (line 109) | static void load_primitive(Archive &ar, T &t){
      type detail (line 114) | namespace detail {
        class iserializer (line 122) | class iserializer : public basic_iserializer
          method destroy (line 125) | void destroy(/*const*/ void *address) const BOOST_OVERRIDE {
          method iserializer (line 129) | explicit iserializer() :
          method class_info (line 142) | bool class_info() const BOOST_OVERRIDE {
          method tracking (line 146) | bool tracking(const unsigned int /* flags */) const BOOST_OVERRI...
          method version_type (line 153) | version_type version() const BOOST_OVERRIDE {
          method is_polymorphic (line 156) | bool is_polymorphic() const BOOST_OVERRIDE {
        function BOOST_DLLEXPORT (line 167) | BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
        type heap_allocation (line 211) | struct heap_allocation {
          method T (line 215) | static T * invoke_new(){
          method invoke_delete (line 218) | static void invoke_delete(T *t){
          type has_new_operator (line 225) | struct has_new_operator {
            method T (line 226) | static T * invoke_new() {
            method invoke_delete (line 229) | static void invoke_delete(T * t) {
          type doesnt_have_new_operator (line 241) | struct doesnt_have_new_operator {
            method T (line 242) | static T* invoke_new() {
            method invoke_delete (line 245) | static void invoke_delete(T * t) {
          method T (line 250) | static T * invoke_new() {
          method invoke_delete (line 259) | static void invoke_delete(T *t) {
          method heap_allocation (line 269) | explicit heap_allocation(){
          method T (line 276) | T* get() const {
          method T (line 280) | T* release() {
        class pointer_iserializer (line 290) | class pointer_iserializer :
          method basic_iserializer (line 300) | const basic_iserializer & get_basic_serializer() const BOOST_OVE...
        function BOOST_DLLEXPORT (line 323) | BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_...
        function BOOST_CATCH (line 348) | BOOST_CATCH(...){
      type load_non_pointer_type (line 380) | struct load_non_pointer_type {
        type load_primitive (line 383) | struct load_primitive {
          method invoke (line 385) | static void invoke(Archive & ar, T & t){
        type load_only (line 391) | struct load_only {
          method invoke (line 393) | static void invoke(Archive & ar, const T & t){
        type load_standard (line 407) | struct load_standard {
          method invoke (line 409) | static void invoke(Archive &ar, const T & t){
        type load_conditional (line 420) | struct load_conditional {
          method invoke (line 422) | static void invoke(Archive &ar, T &t){
        method invoke (line 431) | static void invoke(Archive & ar, T &t){
      type load_pointer_type (line 468) | struct load_pointer_type {
        type abstract (line 469) | struct abstract
          method basic_pointer_iserializer (line 472) | static const basic_pointer_iserializer * register_type(Archive &...
        type non_abstract (line 479) | struct non_abstract
          method basic_pointer_iserializer (line 482) | static const basic_pointer_iserializer * register_type(Archive &...
        method basic_pointer_iserializer (line 488) | static const basic_pointer_iserializer * register_type(Archive &ar...
        method T (line 503) | static T * pointer_tweak(
        method check_load (line 527) | static void check_load(T * const /* t */){
        method basic_pointer_iserializer (line 532) | static const basic_pointer_iserializer *
        method invoke (line 540) | static void invoke(Archive & ar, Tptr & t){
      type load_enum_type (line 560) | struct load_enum_type {
        method invoke (line 562) | static void invoke(Archive &ar, T &t){
      type load_array_type (line 571) | struct load_array_type {
        method invoke (line 573) | static void invoke(Archive &ar, T &t){
    function load (line 606) | inline void load(Archive & ar, T &t){

FILE: include/boost/archive/detail/oserializer.hpp
  type boost (line 76) | namespace boost {
    type serialization (line 78) | namespace serialization {
      class extended_type_info (line 79) | class extended_type_info
    type archive (line 82) | namespace archive {
      class save_access (line 86) | class save_access {
        method end_preamble (line 89) | static void end_preamble(Archive & ar){
        method save_primitive (line 93) | static void save_primitive(Archive & ar, const  T & t){
      type detail (line 99) | namespace detail {
        class oserializer (line 107) | class oserializer : public basic_oserializer
          method class_info (line 125) | bool class_info() const BOOST_OVERRIDE {
          method tracking (line 129) | bool tracking(const unsigned int /* flags */) const BOOST_OVERRI...
          method version_type (line 134) | version_type version() const BOOST_OVERRIDE {
          method is_polymorphic (line 137) | bool is_polymorphic() const BOOST_OVERRIDE {
        function BOOST_DLLEXPORT (line 148) | BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
        class pointer_oserializer (line 168) | class pointer_oserializer :
          method basic_oserializer (line 172) | const basic_oserializer &
        function BOOST_DLLEXPORT (line 192) | BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_...
        type save_non_pointer_type (line 233) | struct save_non_pointer_type {
          type save_primitive (line 236) | struct save_primitive {
            method invoke (line 238) | static void invoke(Archive & ar, const T & t){
          type save_only (line 243) | struct save_only {
            method invoke (line 245) | static void invoke(Archive & ar, const T & t){
          type save_standard (line 257) | struct save_standard {
            method invoke (line 259) | static void invoke(Archive &ar, const T & t){
          type save_conditional (line 273) | struct save_conditional {
            method invoke (line 275) | static void invoke(Archive &ar, const T &t){
          method invoke (line 285) | static void invoke(Archive & ar, const T & t){
          method invoke (line 320) | static void invoke(Archive & ar, T & t){
        type save_pointer_type (line 328) | struct save_pointer_type {
          type abstract (line 329) | struct abstract
            method basic_pointer_oserializer (line 332) | static const basic_pointer_oserializer * register_type(Archive...
          type non_abstract (line 339) | struct non_abstract
            method basic_pointer_oserializer (line 342) | static const basic_pointer_oserializer * register_type(Archive...
          method basic_pointer_oserializer (line 348) | static const basic_pointer_oserializer * register_type(Archive &...
          type non_polymorphic (line 362) | struct non_polymorphic
            method save (line 365) | static void save(
          type polymorphic (line 378) | struct polymorphic
            method save (line 381) | static void save(
          method save (line 458) | static void save(
          method invoke (line 473) | static void invoke(Archive &ar, const TPtr t){
        type save_enum_type (line 487) | struct save_enum_type
          method invoke (line 490) | static void invoke(Archive &ar, const T &t){
        type save_array_type (line 498) | struct save_array_type
          method invoke (line 501) | static void invoke(Archive &ar, const T &t){
      function save (line 526) | inline void save(Archive & ar, /*const*/ T &t){

FILE: include/boost/archive/detail/polymorphic_iarchive_route.hpp
  type std (line 25) | namespace std{
  type boost (line 35) | namespace boost {
    type serialization (line 36) | namespace serialization {
      class extended_type_info (line 37) | class extended_type_info
    type archive (line 39) | namespace archive {
      type detail (line 40) | namespace detail{
        class basic_iserializer (line 42) | class basic_iserializer
        class basic_pointer_iserializer (line 43) | class basic_pointer_iserializer
        class polymorphic_iarchive_route (line 51) | class polymorphic_iarchive_route :
          method load_object (line 59) | void load_object(
          method basic_pointer_iserializer (line 65) | const basic_pointer_iserializer * load_pointer(
          method set_library_version (line 74) | void set_library_version(boost::serialization::library_version_t...
          method get_library_version (line 77) | boost::serialization::library_version_type get_library_version()...
          method get_flags (line 80) | unsigned int get_flags() const BOOST_OVERRIDE {
          method delete_created_pointers (line 83) | void delete_created_pointers() BOOST_OVERRIDE {
          method reset_object_address (line 86) | void reset_object_address(
          method load_binary (line 92) | void load_binary(void * t, std::size_t size) BOOST_OVERRIDE {
          method load (line 96) | void load(bool & t) BOOST_OVERRIDE {
          method load (line 99) | void load(char & t) BOOST_OVERRIDE {
          method load (line 102) | void load(signed char & t) BOOST_OVERRIDE {
          method load (line 105) | void load(unsigned char & t) BOOST_OVERRIDE {
          method load (line 110) | void load(wchar_t & t) BOOST_OVERRIDE {
          method load (line 115) | void load(short & t) BOOST_OVERRIDE {
          method load (line 118) | void load(unsigned short & t) BOOST_OVERRIDE {
          method load (line 124) | void load(unsigned int & t) BOOST_OVERRIDE {
          method load (line 127) | void load(long & t) BOOST_OVERRIDE {
          method load (line 130) | void load(unsigned long & t) BOOST_OVERRIDE {
          method load (line 134) | void load(boost::long_long_type & t) BOOST_OVERRIDE {
          method load (line 137) | void load(boost::ulong_long_type & t) BOOST_OVERRIDE {
          method load (line 141) | void load(__int64 & t) BOOST_OVERRIDE {
          method load (line 144) | void load(unsigned __int64 & t) BOOST_OVERRIDE {
          method load (line 148) | void load(float & t) BOOST_OVERRIDE {
          method load (line 151) | void load(double & t) BOOST_OVERRIDE {
          method load (line 154) | void load(std::string & t) BOOST_OVERRIDE {
          method load (line 158) | void load(std::wstring & t) BOOST_OVERRIDE {
          method load_start (line 163) | void load_start(const char * name) BOOST_OVERRIDE {
          method load_end (line 166) | void load_end(const char * name) BOOST_OVERRIDE {
          method register_basic_serializer (line 169) | void register_basic_serializer(const basic_iserializer & bis) BO...
          method helper_collection (line 172) | helper_collection &
          method polymorphic_iarchive (line 183) | polymorphic_iarchive & operator>>(T & t){
          method polymorphic_iarchive (line 188) | polymorphic_iarchive & operator&(T & t){
          method basic_pointer_iserializer (line 193) | const basic_pointer_iserializer *
          method polymorphic_iarchive_route (line 199) | polymorphic_iarchive_route(

FILE: include/boost/archive/detail/polymorphic_oarchive_route.hpp
  type std (line 25) | namespace std{
  type boost (line 35) | namespace boost {
    type serialization (line 36) | namespace serialization {
      class extended_type_info (line 37) | class extended_type_info
    type archive (line 39) | namespace archive {
      type detail (line 40) | namespace detail{
        class basic_oserializer (line 42) | class basic_oserializer
        class basic_pointer_oserializer (line 43) | class basic_pointer_oserializer
        class polymorphic_oarchive_route (line 51) | class polymorphic_oarchive_route :
          method save_object (line 59) | void save_object(
          method save_pointer (line 65) | void save_pointer(
          method save_null_pointer (line 71) | void save_null_pointer() BOOST_OVERRIDE {
          method save (line 75) | void save(const bool t) BOOST_OVERRIDE {
          method save (line 78) | void save(const char t) BOOST_OVERRIDE {
          method save (line 81) | void save(const signed char t) BOOST_OVERRIDE {
          method save (line 84) | void save(const unsigned char t) BOOST_OVERRIDE {
          method save (line 89) | void save(const wchar_t t) BOOST_OVERRIDE {
          method save (line 94) | void save(const short t) BOOST_OVERRIDE {
          method save (line 97) | void save(const unsigned short t) BOOST_OVERRIDE {
          method save (line 100) | void save(const int t) BOOST_OVERRIDE {
          method save (line 103) | void save(const unsigned int t) BOOST_OVERRIDE {
          method save (line 106) | void save(const long t) BOOST_OVERRIDE {
          method save (line 109) | void save(const unsigned long t) BOOST_OVERRIDE {
          method save (line 113) | void save(const boost::long_long_type t) BOOST_OVERRIDE {
          method save (line 116) | void save(const boost::ulong_long_type t) BOOST_OVERRIDE {
          method save (line 120) | void save(const boost::int64_t t) BOOST_OVERRIDE {
          method save (line 123) | void save(const boost::uint64_t t) BOOST_OVERRIDE {
          method save (line 127) | void save(const float t) BOOST_OVERRIDE {
          method save (line 130) | void save(const double t) BOOST_OVERRIDE {
          method save (line 133) | void save(const std::string & t) BOOST_OVERRIDE {
          method save (line 137) | void save(const std::wstring & t) BOOST_OVERRIDE {
          method get_library_version (line 141) | boost::serialization::library_version_type get_library_version()...
          method get_flags (line 144) | unsigned int get_flags() const BOOST_OVERRIDE {
          method save_binary (line 147) | void save_binary(const void * t, std::size_t size) BOOST_OVERRIDE {
          method save_start (line 151) | void save_start(const char * name) BOOST_OVERRIDE {
          method save_end (line 154) | void save_end(const char * name) BOOST_OVERRIDE {
          method end_preamble (line 157) | void end_preamble() BOOST_OVERRIDE {
          method register_basic_serializer (line 160) | void register_basic_serializer(const detail::basic_oserializer &...
          method helper_collection (line 163) | helper_collection &
          method polymorphic_oarchive (line 174) | polymorphic_oarchive & operator<<(T & t){
          method polymorphic_oarchive (line 179) | polymorphic_oarchive & operator&(T & t){
          method basic_pointer_oserializer (line 184) | const basic_pointer_oserializer *
          method polymorphic_oarchive_route (line 190) | polymorphic_oarchive_route(

FILE: include/boost/archive/detail/register_archive.hpp
  type boost (line 7) | namespace boost { namespace archive { namespace detail {
    type archive (line 7) | namespace archive { namespace detail {
      type detail (line 7) | namespace detail {
        type adl_tag (line 15) | struct adl_tag {}
        type ptr_serialization_support (line 18) | struct ptr_serialization_support
        type _ptr_serialization_support (line 25) | struct _ptr_serialization_support
        type counter (line 34) | struct counter : counter<N-1> {}
        type counter<0> (line 36) | struct counter<0> {}
        function instantiate_ptr_serialization (line 39) | void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
        type get_counter (line 44) | struct get_counter {
        function instantiate_ptr_serialization (line 53) | void instantiate_ptr_serialization(Serializable*, counter<0>) {}
        function instantiate_ptr_serialization (line 73) | void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}

FILE: include/boost/archive/dinkumware.hpp
  type std (line 28) | namespace std {
    class back_insert_iterator<basic_string<char> > (line 131) | class back_insert_iterator<basic_string<char> > : public
      method back_insert_iterator (line 138) | explicit back_insert_iterator(container_type & s)
    function back_inserter (line 169) | inline back_insert_iterator<basic_string<char> > back_inserter(
    class back_insert_iterator<basic_string<wchar_t> > (line 176) | class back_insert_iterator<basic_string<wchar_t> > : public
      method back_insert_iterator (line 183) | explicit back_insert_iterator(container_type & s)
    function back_inserter (line 214) | inline back_insert_iterator<basic_string<wchar_t> > back_inserter(

FILE: include/boost/archive/impl/basic_xml_grammar.hpp
  type boost (line 60) | namespace boost {
    type archive (line 61) | namespace archive {
      function basic_xml_grammar (line 67) | class BOOST_SYMBOL_VISIBLE basic_xml_grammar {

FILE: include/boost/archive/iterators/base64_exception.hpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      type iterators (line 27) | namespace iterators {
        class base64_exception (line 32) | class base64_exception : public std::exception
          method base64_exception (line 42) | base64_exception(exception_code c = other_exception) : code(c)

FILE: include/boost/archive/iterators/base64_from_binary.hpp
  type std (line 23) | namespace std{
  type boost (line 31) | namespace boost {
    type archive (line 32) | namespace archive {
      type iterators (line 33) | namespace iterators {
        type detail (line 38) | namespace detail {
          type from_6_bit (line 41) | struct from_6_bit {
            method CharType (line 43) | CharType operator()(CharType t) const{
        class base64_from_binary (line 74) | class base64_from_binary :
          method base64_from_binary (line 89) | base64_from_binary(T start) :
          method base64_from_binary (line 96) | base64_from_binary(const base64_from_binary & rhs) :

FILE: include/boost/archive/iterators/binary_from_base64.hpp
  type boost (line 27) | namespace boost {
    type archive (line 28) | namespace archive {
      type iterators (line 29) | namespace iterators {
        type detail (line 34) | namespace detail {
          type to_6_bit (line 37) | struct to_6_bit {
            method CharType (line 39) | CharType operator()(CharType t) const{
        class binary_from_base64 (line 84) | class binary_from_base64 : public
          method binary_from_base64 (line 98) | binary_from_base64(T  start) :
          method binary_from_base64 (line 105) | binary_from_base64(const binary_from_base64 & rhs) :

FILE: include/boost/archive/iterators/dataflow.hpp
  type boost (line 34) | namespace boost {
    type archive (line 35) | namespace archive {
      type iterators (line 36) | namespace iterators {
        type tri_state (line 39) | struct tri_state {
          type state_enum (line 40) | enum state_enum {
          method tri_state (line 51) | tri_state & operator=(bool rhs) {
          method tri_state (line 55) | tri_state(bool rhs) :
          method tri_state (line 58) | tri_state(state_enum state) :
        class dataflow (line 72) | class dataflow {
          method tri_state (line 76) | tri_state equal(const Derived & rhs) const {
          method eoi (line 83) | void eoi(bool tf){
          method eoi (line 86) | bool eoi() const {
          method dataflow (line 90) | dataflow(bool tf) :
          method dataflow (line 93) | dataflow() : // used for iterator end

FILE: include/boost/archive/iterators/dataflow_exception.hpp
  type boost (line 26) | namespace boost {
    type archive (line 27) | namespace archive {
      type iterators (line 28) | namespace iterators {
        class dataflow_exception (line 33) | class dataflow_exception : public std::exception
          method dataflow_exception (line 46) | dataflow_exception(exception_code c = other_exception) : code(c)
          method BOOST_NOEXCEPT_OR_NOTHROW (line 49) | BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE

FILE: include/boost/archive/iterators/escape.hpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      type iterators (line 27) | namespace iterators {
        class escape (line 33) | class escape :
          method dereference_impl (line 56) | void dereference_impl() {
          method reference_type (line 62) | reference_type dereference() const {
          method equal (line 68) | bool equal(const this_t & rhs) const {
          method increment (line 84) | void increment(){
          method escape (line 101) | escape(Base base) :

FILE: include/boost/archive/iterators/insert_linebreaks.hpp
  type std (line 23) | namespace std{ using ::memcpy; }
  type boost (line 29) | namespace boost {
    type archive (line 30) | namespace archive {
      type iterators (line 31) | namespace iterators {
        class insert_linebreaks (line 40) | class insert_linebreaks :
          method equal (line 59) | bool equal(const insert_linebreaks<Base, N, CharType> & rhs) con...
          method increment (line 67) | void increment() {
          method CharType (line 75) | CharType dereference() const {
          method insert_linebreaks (line 84) | insert_linebreaks(T  start) :
          method insert_linebreaks (line 89) | insert_linebreaks(const insert_linebreaks & rhs) :

FILE: include/boost/archive/iterators/istream_iterator.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      type iterators (line 30) | namespace iterators {
        class istream_iterator (line 34) | class istream_iterator :
          method equal (line 52) | bool equal(const this_t & rhs) const {
          method Elem (line 58) | Elem dereference() const {
          method increment (line 62) | void increment(){
          method istream_iterator (line 71) | istream_iterator(istream_type & is) :
          method istream_iterator (line 77) | istream_iterator() :
          method istream_iterator (line 82) | istream_iterator(const istream_iterator<Elem> & rhs) :

FILE: include/boost/archive/iterators/mb_from_wchar.hpp
  type std (line 27) | namespace std{
  type boost (line 36) | namespace boost {
    type archive (line 37) | namespace archive {
      type iterators (line 38) | namespace iterators {
        class mb_from_wchar (line 44) | class mb_from_wchar
          method dereference_impl (line 65) | char dereference_impl() {
          method dereference (line 73) | char dereference() const {
          method equal (line 77) | bool equal(const mb_from_wchar<Base> & rhs) const {
          method fill (line 87) | void fill(){
          method increment (line 104) | void increment(){
          method mb_from_wchar (line 124) | mb_from_wchar(T start) :
          method mb_from_wchar (line 132) | mb_from_wchar(const mb_from_wchar & rhs) :

FILE: include/boost/archive/iterators/ostream_iterator.hpp
  type boost (line 27) | namespace boost {
    type archive (line 28) | namespace archive {
      type iterators (line 29) | namespace iterators {
        class ostream_iterator (line 33) | class ostream_iterator :
          method ostream_iterator (line 47) | ostream_iterator & dereference() const {
          method equal (line 50) | bool equal(const this_t & rhs) const {
          method increment (line 53) | void increment(){}
          method put_val (line 56) | void put_val(char_type e){
          method this_t (line 64) | this_t & operator=(char_type c){
          method ostream_iterator (line 68) | ostream_iterator(ostream_type & os) :
          method ostream_iterator (line 71) | ostream_iterator() :
          method ostream_iterator (line 74) | ostream_iterator(const ostream_iterator & rhs) :

FILE: include/boost/archive/iterators/remove_whitespace.hpp
  type std (line 34) | namespace std{ using ::iswspace; }
  type std (line 40) | namespace std{ using ::isspace; }
  type remove_whitespace_predicate (line 52) | struct remove_whitespace_predicate
  type remove_whitespace_predicate<char> (line 55) | struct remove_whitespace_predicate<char>
  type remove_whitespace_predicate<wchar_t> (line 64) | struct remove_whitespace_predicate<wchar_t>
  type boost (line 77) | namespace boost {
    type archive (line 78) | namespace archive {
      type iterators (line 79) | namespace iterators {
        class filter_iterator (line 85) | class filter_iterator
          method reference_type (line 103) | reference_type dereference_impl(){
          method reference_type (line 112) | reference_type dereference() const {
          method increment (line 121) | void increment(){
          method filter_iterator (line 125) | filter_iterator(Base start) :
          method filter_iterator (line 129) | filter_iterator(){}
        class remove_whitespace (line 133) | class remove_whitespace :
          method remove_whitespace (line 154) | remove_whitespace(T start) :
          method remove_whitespace (line 158) | remove_whitespace(const remove_whitespace & rhs) :

FILE: include/boost/archive/iterators/transform_width.hpp
  type boost (line 32) | namespace boost {
    type archive (line 33) | namespace archive {
      type iterators (line 34) | namespace iterators {
        class transform_width (line 45) | class transform_width :
          method CharType (line 68) | CharType dereference() const {
          method equal_impl (line 74) | bool equal_impl(const this_t & rhs){
          method equal (line 88) | bool equal(const this_t & rhs) const {
          method increment (line 92) | void increment(){
          method transform_width (line 111) | transform_width(T start) :
          method transform_width (line 123) | transform_width(const transform_width & rhs) :

FILE: include/boost/archive/iterators/unescape.hpp
  type boost (line 24) | namespace boost {
    type archive (line 25) | namespace archive {
      type iterators (line 26) | namespace iterators {
        class unescape (line 32) | class unescape
          method value_type (line 55) | value_type dereference_impl() {
          method reference (line 63) | reference dereference() const {
          method increment (line 70) | void increment(){
          method unescape (line 78) | unescape(Base base) :

FILE: include/boost/archive/iterators/wchar_from_mb.hpp
  type std (line 28) | namespace std{
  type boost (line 42) | namespace boost {
    type archive (line 43) | namespace archive {
      type iterators (line 44) | namespace iterators {
        class wchar_from_mb (line 50) | class wchar_from_mb
          method wchar_t (line 72) | wchar_t dereference() const {
          method increment (line 78) | void increment(){
          method equal (line 88) | bool equal(this_t const & rhs) const {
          type sliding_buffer (line 96) | struct sliding_buffer {
            method sliding_buffer (line 102) | sliding_buffer() :
            method sliding_buffer (line 108) | sliding_buffer(const sliding_buffer & rhs) :
          method wchar_from_mb (line 129) | wchar_from_mb(T start) :
          method wchar_from_mb (line 137) | wchar_from_mb(){}
          method wchar_from_mb (line 140) | wchar_from_mb(const wchar_from_mb & rhs) :

FILE: include/boost/archive/iterators/xml_escape.hpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type iterators (line 24) | namespace iterators {
        class xml_escape (line 30) | class xml_escape
          method xml_escape (line 42) | xml_escape(T start) :
          method xml_escape (line 46) | xml_escape(const xml_escape & rhs) :
        function wchar_t (line 87) | wchar_t xml_escape<Base>::fill(

FILE: include/boost/archive/iterators/xml_unescape.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      type iterators (line 30) | namespace iterators {
        class xml_unescape (line 35) | class xml_unescape
          method reference_type (line 43) | reference_type dereference() const {
          method xml_unescape (line 58) | xml_unescape(T start) :
          method xml_unescape (line 62) | xml_unescape(const xml_unescape & rhs) :

FILE: include/boost/archive/iterators/xml_unescape_exception.hpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      type iterators (line 27) | namespace iterators {
        class xml_unescape_exception (line 32) | class xml_unescape_exception : public std::exception
          method xml_unescape_exception (line 35) | xml_unescape_exception()

FILE: include/boost/archive/polymorphic_binary_iarchive.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 31) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_binary_oarchive.hpp
  type boost (line 23) | namespace boost {
    type archive (line 24) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 26) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_iarchive.hpp
  type std (line 25) | namespace std{
  type boost (line 41) | namespace boost {
    type serialization (line 42) | namespace serialization {
      class extended_type_info (line 43) | class extended_type_info
    type archive (line 45) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_iarchive (line 47) | class basic_iarchive
        class basic_iserializer (line 48) | class basic_iserializer
      class polymorphic_iarchive (line 51) | class polymorphic_iarchive
      class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 106) | void load_override(T & t)
      function load_override (line 112) | void load_override(
      class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE
    type archive (line 156) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_iarchive (line 47) | class basic_iarchive
        class basic_iserializer (line 48) | class basic_iserializer
      class polymorphic_iarchive (line 51) | class polymorphic_iarchive
      class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 106) | void load_override(T & t)
      function load_override (line 112) | void load_override(
      class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE
  type boost (line 155) | namespace boost {
    type serialization (line 42) | namespace serialization {
      class extended_type_info (line 43) | class extended_type_info
    type archive (line 45) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_iarchive (line 47) | class basic_iarchive
        class basic_iserializer (line 48) | class basic_iserializer
      class polymorphic_iarchive (line 51) | class polymorphic_iarchive
      class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 106) | void load_override(T & t)
      function load_override (line 112) | void load_override(
      class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE
    type archive (line 156) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_iarchive (line 47) | class basic_iarchive
        class basic_iserializer (line 48) | class basic_iserializer
      class polymorphic_iarchive (line 51) | class polymorphic_iarchive
      class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
      function load_override (line 106) | void load_override(T & t)
      function load_override (line 112) | void load_override(
      class BOOST_SYMBOL_VISIBLE (line 158) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_oarchive.hpp
  type std (line 25) | namespace std{
  type boost (line 39) | namespace boost {
    type serialization (line 40) | namespace serialization {
      class extended_type_info (line 41) | class extended_type_info
    type archive (line 43) | namespace archive {
      type detail (line 44) | namespace detail {
        class basic_oarchive (line 45) | class basic_oarchive
        class basic_oserializer (line 46) | class basic_oserializer
      class polymorphic_oarchive (line 49) | class polymorphic_oarchive
      class BOOST_SYMBOL_VISIBLE (line 51) | class BOOST_SYMBOL_VISIBLE
      function save_override (line 107) | void save_override(T & t)
      function save_override (line 113) | void save_override(
      class BOOST_SYMBOL_VISIBLE (line 139) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_text_iarchive.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 31) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_text_oarchive.hpp
  type boost (line 23) | namespace boost {
    type archive (line 24) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 26) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_text_wiarchive.hpp
  type boost (line 32) | namespace boost {
    type archive (line 33) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 35) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_text_woarchive.hpp
  type boost (line 27) | namespace boost {
    type archive (line 28) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 30) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_xml_iarchive.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 31) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_xml_oarchive.hpp
  type boost (line 23) | namespace boost {
    type archive (line 24) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 26) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_xml_wiarchive.hpp
  type boost (line 27) | namespace boost {
    type archive (line 28) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 30) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/polymorphic_xml_woarchive.hpp
  type boost (line 27) | namespace boost {
    type archive (line 28) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 30) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/text_iarchive.hpp
  type boost (line 35) | namespace boost {
    type archive (line 36) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
      function load (line 55) | void load(T & t){
      function load (line 58) | void load(version_type & t){
      function load (line 63) | void load(boost::serialization::item_version_type & t){
      function load_override (line 81) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE
    type archive (line 110) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
      function load (line 55) | void load(T & t){
      function load (line 58) | void load(version_type & t){
      function load (line 63) | void load(boost::serialization::item_version_type & t){
      function load_override (line 81) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE
  type boost (line 109) | namespace boost {
    type archive (line 36) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
      function load (line 55) | void load(T & t){
      function load (line 58) | void load(version_type & t){
      function load (line 63) | void load(boost::serialization::item_version_type & t){
      function load_override (line 81) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE
    type archive (line 110) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 43) | class BOOST_SYMBOL_VISIBLE
      function load (line 55) | void load(T & t){
      function load (line 58) | void load(version_type & t){
      function load (line 63) | void load(boost::serialization::item_version_type & t){
      function load_override (line 81) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 112) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/text_oarchive.hpp
  type std (line 24) | namespace std{
  type boost (line 42) | namespace boost {
    type archive (line 43) | namespace archive {
      type detail (line 45) | namespace detail {
        class interface_oarchive (line 46) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
      function save (line 63) | void save(const T & t){
      function save (line 67) | void save(const version_type & t){
      function save (line 70) | void save(const boost::serialization::item_version_type & t){
    class BOOST_SYMBOL_VISIBLE (line 98) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/text_wiarchive.hpp
  type boost (line 39) | namespace boost {
    type archive (line 40) | namespace archive {
      type detail (line 42) | namespace detail {
        class interface_iarchive (line 43) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void load(version_type & t){
      function load (line 74) | void load(boost::serialization::item_version_type & t){
      function load_override (line 92) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
    type archive (line 115) | namespace archive {
      type detail (line 42) | namespace detail {
        class interface_iarchive (line 43) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void load(version_type & t){
      function load (line 74) | void load(boost::serialization::item_version_type & t){
      function load_override (line 92) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
  type boost (line 114) | namespace boost {
    type archive (line 40) | namespace archive {
      type detail (line 42) | namespace detail {
        class interface_iarchive (line 43) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void load(version_type & t){
      function load (line 74) | void load(boost::serialization::item_version_type & t){
      function load_override (line 92) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
    type archive (line 115) | namespace archive {
      type detail (line 42) | namespace detail {
        class interface_iarchive (line 43) | class interface_iarchive
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void load(version_type & t){
      function load (line 74) | void load(boost::serialization::item_version_type & t){
      function load_override (line 92) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/text_woarchive.hpp
  type std (line 29) | namespace std{
  type boost (line 47) | namespace boost {
    type archive (line 48) | namespace archive {
      type detail (line 50) | namespace detail {
        class interface_oarchive (line 51) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 55) | class BOOST_SYMBOL_VISIBLE
      function save (line 76) | void save(const T & t){
      function save (line 80) | void save(const version_type & t){
      function save (line 83) | void save(const boost::serialization::item_version_type & t){
      function text_woarchive_impl (line 98) | text_woarchive_impl(std::wostream & os, unsigned int flags) :
      class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/tmpdir.hpp
  type std (line 24) | namespace std {
  type boost (line 29) | namespace boost {
    type archive (line 30) | namespace archive {

FILE: include/boost/archive/wcslen.hpp
  type std (line 22) | namespace std{
    function wcslen (line 36) | inline std::size_t wcslen(const wchar_t * ws)
  type std (line 35) | namespace std {
    function wcslen (line 36) | inline std::size_t wcslen(const wchar_t * ws)
  type std (line 51) | namespace std{ using ::wcslen; }
    function wcslen (line 36) | inline std::size_t wcslen(const wchar_t * ws)

FILE: include/boost/archive/xml_archive_exception.hpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class BOOST_SYMBOL_VISIBLE (line 34) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/xml_iarchive.hpp
  type boost (line 35) | namespace boost {
    type archive (line 36) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class basic_xml_grammar (line 43) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void
      function load (line 75) | void
      function load_override (line 94) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE
    type archive (line 121) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class basic_xml_grammar (line 43) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void
      function load (line 75) | void
      function load_override (line 94) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE
  type boost (line 120) | namespace boost {
    type archive (line 36) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class basic_xml_grammar (line 43) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void
      function load (line 75) | void
      function load_override (line 94) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE
    type archive (line 121) | namespace archive {
      type detail (line 38) | namespace detail {
        class interface_iarchive (line 39) | class interface_iarchive
      class basic_xml_grammar (line 43) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 47) | class BOOST_SYMBOL_VISIBLE
      function load (line 66) | void load(T & t){
      function load (line 69) | void
      function load (line 75) | void
      function load_override (line 94) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 123) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/xml_oarchive.hpp
  type std (line 24) | namespace std{
  type boost (line 42) | namespace boost {
    type archive (line 43) | namespace archive {
      type detail (line 45) | namespace detail {
        class interface_oarchive (line 46) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
      function save (line 63) | void save(const T & t){
      function save (line 66) | void
      function save (line 70) | void
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
    type archive (line 109) | namespace archive {
      type detail (line 45) | namespace detail {
        class interface_oarchive (line 46) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
      function save (line 63) | void save(const T & t){
      function save (line 66) | void
      function save (line 70) | void
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
  type boost (line 108) | namespace boost {
    type archive (line 43) | namespace archive {
      type detail (line 45) | namespace detail {
        class interface_oarchive (line 46) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
      function save (line 63) | void save(const T & t){
      function save (line 66) | void
      function save (line 70) | void
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE
    type archive (line 109) | namespace archive {
      type detail (line 45) | namespace detail {
        class interface_oarchive (line 46) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 50) | class BOOST_SYMBOL_VISIBLE
      function save (line 63) | void save(const T & t){
      function save (line 66) | void
      function save (line 70) | void
      class BOOST_SYMBOL_VISIBLE (line 117) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/xml_wiarchive.hpp
  type boost (line 40) | namespace boost {
    type archive (line 41) | namespace archive {
      type detail (line 43) | namespace detail {
        class interface_iarchive (line 44) | class interface_iarchive
      class basic_xml_grammar (line 48) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
      function load (line 70) | void
      function load (line 74) | void
      function load (line 80) | void
      function load_override (line 99) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
    type archive (line 127) | namespace archive {
      type detail (line 43) | namespace detail {
        class interface_iarchive (line 44) | class interface_iarchive
      class basic_xml_grammar (line 48) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
      function load (line 70) | void
      function load (line 74) | void
      function load (line 80) | void
      function load_override (line 99) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
  type boost (line 126) | namespace boost {
    type archive (line 41) | namespace archive {
      type detail (line 43) | namespace detail {
        class interface_iarchive (line 44) | class interface_iarchive
      class basic_xml_grammar (line 48) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
      function load (line 70) | void
      function load (line 74) | void
      function load (line 80) | void
      function load_override (line 99) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE
    type archive (line 127) | namespace archive {
      type detail (line 43) | namespace detail {
        class interface_iarchive (line 44) | class interface_iarchive
      class basic_xml_grammar (line 48) | class basic_xml_grammar
      class BOOST_SYMBOL_VISIBLE (line 52) | class BOOST_SYMBOL_VISIBLE
      function load (line 70) | void
      function load (line 74) | void
      function load (line 80) | void
      function load_override (line 99) | void load_override(T & t){
      class BOOST_SYMBOL_VISIBLE (line 129) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/archive/xml_woarchive.hpp
  type std (line 25) | namespace std{
  type boost (line 45) | namespace boost {
    type archive (line 46) | namespace archive {
      type detail (line 48) | namespace detail {
        class interface_oarchive (line 49) | class interface_oarchive
      class BOOST_SYMBOL_VISIBLE (line 53) | class BOOST_SYMBOL_VISIBLE
      function save (line 69) | void
      function save (line 73) | void
      function save (line 77) | void
    class BOOST_SYMBOL_VISIBLE (line 109) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/serialization/access.hpp
  type boost (line 21) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class iserializer (line 26) | class iserializer
        class oserializer (line 28) | class oserializer
    type serialization (line 32) | namespace serialization {
      type detail (line 37) | namespace detail {
        type member_saver (line 39) | struct member_saver
        type member_loader (line 41) | struct member_loader
      class access (line 49) | class access {
        method member_save (line 85) | static void member_save(
        method member_load (line 94) | static void member_load(
        method serialize (line 102) | static void serialize(
        method destroy (line 119) | static void destroy( const T * t) // const appropriate here?
        method construct (line 126) | static void construct(T * t){
        method T (line 133) | static T & cast_reference(U & u){
        method T (line 137) | static T * cast_pointer(U * u){

FILE: include/boost/serialization/archive_input_unordered_map.hpp
  type boost (line 27) | namespace boost {
    type serialization (line 28) | namespace serialization {
      type stl (line 29) | namespace stl {
        type archive_input_unordered_map (line 33) | struct archive_input_unordered_map
        type archive_input_unordered_multimap (line 59) | struct archive_input_unordered_multimap

FILE: include/boost/serialization/archive_input_unordered_set.hpp
  type boost (line 25) | namespace boost {
    type serialization (line 26) | namespace serialization {
      type stl (line 28) | namespace stl {
        type archive_input_unordered_set (line 32) | struct archive_input_unordered_set
        type archive_input_unordered_multiset (line 52) | struct archive_input_unordered_multiset

FILE: include/boost/serialization/array.hpp
  type std (line 21) | namespace std{
  type boost (line 33) | namespace boost { namespace serialization {
    type serialization (line 33) | namespace serialization {
      function serialize (line 36) | void serialize(Archive& ar, std::array<T,N>& a, const unsigned int /...

FILE: include/boost/serialization/array_optimization.hpp
  type std (line 12) | namespace std{
  type boost (line 21) | namespace boost { namespace serialization {
    type serialization (line 21) | namespace serialization {
      type use_array_optimization (line 24) | struct use_array_optimization : boost::mpl::always<boost::mpl::false...

FILE: include/boost/serialization/array_wrapper.hpp
  type std (line 12) | namespace std{
  type boost (line 27) | namespace boost { namespace serialization {
    type serialization (line 27) | namespace serialization {
      class array_wrapper (line 30) | class array_wrapper :
        method array_wrapper (line 41) | array_wrapper(const array_wrapper & rhs) :
        method array_wrapper (line 46) | array_wrapper(T * t, std::size_t s) :
        method serialize_optimized (line 53) | void serialize_optimized(Archive &ar, const unsigned int, mpl::fal...
        method serialize_optimized (line 64) | void serialize_optimized(Archive &ar, const unsigned int version, ...
        method save (line 71) | void save(Archive &ar, const unsigned int version) const
        method load (line 78) | void load(Archive &ar, const unsigned int version)
        method serialize (line 85) | void serialize(Archive &ar, const unsigned int version)
        method T (line 94) | T * address() const
        method count (line 99) | std::size_t count() const
      function make_array (line 110) | inline

FILE: include/boost/serialization/assume_abstract.hpp
  type boost (line 30) | namespace boost {
    type serialization (line 31) | namespace serialization {
      type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
      type is_abstract (line 43) | struct is_abstract : boost::false_type {}
    type serialization (line 41) | namespace serialization {
      type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
      type is_abstract (line 43) | struct is_abstract : boost::false_type {}
  type boost (line 40) | namespace boost {
    type serialization (line 31) | namespace serialization {
      type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
      type is_abstract (line 43) | struct is_abstract : boost::false_type {}
    type serialization (line 41) | namespace serialization {
      type is_abstract (line 33) | struct is_abstract : boost::is_abstract< T > {}
      type is_abstract (line 43) | struct is_abstract : boost::false_type {}

FILE: include/boost/serialization/base_object.hpp
  type boost (line 40) | namespace boost {
    type serialization (line 41) | namespace serialization {
      type detail (line 43) | namespace detail
        type base_cast (line 48) | struct base_cast
        type base_register (line 61) | struct base_register
          type polymorphic (line 63) | struct polymorphic {
          type non_polymorphic (line 70) | struct non_polymorphic {

FILE: include/boost/serialization/binary_object.hpp
  type std (line 24) | namespace std{
  type boost (line 36) | namespace boost {
    type serialization (line 37) | namespace serialization {
      type binary_object (line 39) | struct binary_object :
        method save (line 45) | void save(Archive & ar, const unsigned int /* file_version */) con...
        method load (line 49) | void load(Archive & ar, const unsigned int /* file_version */) con...
        method binary_object (line 53) | binary_object & operator=(const binary_object & rhs) {
        method binary_object (line 58) | binary_object(const void * const t, std::size_t size) :
        method binary_object (line 62) | binary_object(const binary_object & rhs) :
      function binary_object (line 70) | inline
        method save (line 45) | void save(Archive & ar, const unsigned int /* file_version */) con...
        method load (line 49) | void load(Archive & ar, const unsigned int /* file_version */) con...
        method binary_object (line 53) | binary_object & operator=(const binary_object & rhs) {
        method binary_object (line 58) | binary_object(const void * const t, std::size_t size) :
        method binary_object (line 62) | binary_object(const binary_object & rhs) :

FILE: include/boost/serialization/bitset.hpp
  type boost (line 26) | namespace boost{
    type serialization (line 27) | namespace serialization{
      function save (line 30) | inline void save(
      function load (line 44) | inline void load(
      function serialize (line 55) | inline void serialize(
      type tracking_level<std::bitset<size> > (line 69) | struct tracking_level<std::bitset<size> >

FILE: include/boost/serialization/boost_array.hpp
  type std (line 12) | namespace std{
  type boost (line 20) | namespace boost { namespace serialization {
    type serialization (line 20) | namespace serialization {
      function serialize (line 23) | void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int...

FILE: include/boost/serialization/collection_size_type.hpp
  type boost (line 15) | namespace boost {
    type serialization (line 16) | namespace serialization {
      class collection_size_type (line 20) | class collection_size_type {
        method collection_size_type (line 25) | collection_size_type(): t(0) {}
        method collection_size_type (line 26) | explicit collection_size_type(const std::size_t & t_) :
        method collection_size_type (line 29) | collection_size_type(const collection_size_type & t_) :
        method collection_size_type (line 32) | collection_size_type & operator=(const collection_size_type & rhs){
        method collection_size_type (line 36) | collection_size_type & operator=(const unsigned int & rhs){

FILE: include/boost/serialization/collections_load_imp.hpp
  type std (line 29) | namespace std{
  type boost (line 44) | namespace boost{
    type serialization (line 45) | namespace serialization {
      type stl (line 46) | namespace stl {
        function collection_load_impl (line 56) | typename boost::enable_if<
        function collection_load_impl (line 80) | typename boost::disable_if<

FILE: include/boost/serialization/collections_save_imp.hpp
  type boost (line 29) | namespace boost{
    type serialization (line 30) | namespace serialization {
      type stl (line 31) | namespace stl {
        function save_collection (line 38) | inline void save_collection(
        function save_collection (line 64) | inline void save_collection(Archive & ar, const Container &s)

FILE: include/boost/serialization/complex.hpp
  type boost (line 27) | namespace boost {
    type serialization (line 28) | namespace serialization {
      function serialize (line 31) | inline void serialize(
      function save (line 40) | inline void save(
      function load (line 52) | inline void load(
      type is_bitwise_serializable<std::complex< T > > (line 66) | struct is_bitwise_serializable<std::complex< T > >
      type implementation_level<std::complex< T > > (line 70) | struct implementation_level<std::complex< T > >
      type tracking_level<std::complex< T > > (line 75) | struct tracking_level<std::complex< T > >

FILE: include/boost/serialization/deque.hpp
  type boost (line 28) | namespace boost {
    type serialization (line 29) | namespace serialization {
      function save (line 32) | inline void save(
      function load (line 43) | inline void load(
      function serialize (line 64) | inline void serialize(

FILE: include/boost/serialization/detail/is_default_constructible.hpp
  type boost (line 23) | namespace boost{
    type serialization (line 24) | namespace serialization {
      type detail (line 25) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
      type detail (line 42) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
    type serialization (line 41) | namespace serialization {
      type detail (line 25) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
      type detail (line 42) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
  type boost (line 40) | namespace boost{
    type serialization (line 24) | namespace serialization {
      type detail (line 25) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
      type detail (line 42) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
    type serialization (line 41) | namespace serialization {
      type detail (line 25) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...
      type detail (line 42) | namespace detail {
        type is_default_constructible (line 28) | struct is_default_constructible : public std::is_default_construct...
        type is_default_constructible (line 45) | struct is_default_constructible : public boost::has_trivial_constr...

FILE: include/boost/serialization/detail/shared_count_132.hpp
  type std (line 43) | namespace std{
  class bad_weak_ptr (line 69) | class bad_weak_ptr: public std::exception
  class sp_counted_base (line 81) | class sp_counted_base
    method sp_counted_base (line 89) | sp_counted_base(): use_count_(1), weak_count_(1)
    method destruct (line 104) | virtual void destruct() // nothrow
    method add_ref_copy (line 111) | void add_ref_copy()
    method add_ref_lock (line 119) | void add_ref_lock()
    method release (line 128) | void release() // nothrow
    method weak_add_ref (line 143) | void weak_add_ref() // nothrow
    method weak_release (line 151) | void weak_release() // nothrow
    method use_count (line 168) | long use_count() const // nothrow
  function cbi_call_constructor_hook (line 191) | void cbi_call_constructor_hook(sp_counted_base * pn, T * px, boost::chec...
  function cbi_call_constructor_hook (line 196) | void cbi_call_constructor_hook(sp_counted_base *, T * px, boost::checked...
  function cbi_call_constructor_hook (line 201) | void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, ...
  function cbi_call_destructor_hook (line 205) | void cbi_call_destructor_hook(sp_counted_base * pn, T * px, boost::check...
  function cbi_call_destructor_hook (line 210) | void cbi_call_destructor_hook(sp_counted_base *, T * px, boost::checked_...
  function cbi_call_destructor_hook (line 215) | void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, l...
  class sp_counted_base_impl (line 228) | class sp_counted_base_impl: public sp_counted_base
    method sp_counted_base_impl (line 244) | sp_counted_base_impl(P p, D d): ptr(p), del(d)
    method dispose (line 251) | virtual void dispose() // nothrow
  class weak_count (line 300) | class weak_count
  function id_ (line 318) | id_(shared_count_id)
  function id_ (line 325) | id_(shared_count_id)
  function shared_count (line 358) | explicit shared_count(std::auto_ptr<Y> & r): pi_(
  function id_ (line 382) | id_(shared_count_id)
  function shared_count (line 390) | shared_count & operator= (shared_count const & r) // nothrow
  function swap (line 404) | void swap(shared_count & r) // nothrow
  function use_count (line 411) | long use_count() const // nothrow
  function unique (line 416) | bool unique() const // nothrow
  function id_ (line 458) | id_(weak_count_id)
  function id_ (line 465) | id_(shared_count_id)
  function id_ (line 473) | id_(shared_count_id)
  function weak_count (line 487) | weak_count & operator= (shared_count const & r) // nothrow
  function weak_count (line 497) | weak_count & operator= (weak_count const & r) // nothrow
  function swap (line 507) | void swap(weak_count & r) // nothrow
  function use_count (line 514) | long use_count() const // nothrow
  function id_ (line 532) | id_(shared_count_id)

FILE: include/boost/serialization/detail/shared_ptr_132.hpp
  type boost_132 (line 42) | namespace boost_132 {
    class weak_ptr (line 44) | class weak_ptr
    class enable_shared_from_this (line 45) | class enable_shared_from_this
    type detail (line 47) | namespace detail
      type static_cast_tag (line 50) | struct static_cast_tag {}
      type const_cast_tag (line 51) | struct const_cast_tag {}
      type dynamic_cast_tag (line 52) | struct dynamic_cast_tag {}
      type polymorphic_cast_tag (line 53) | struct polymorphic_cast_tag {}
      type shared_ptr_traits (line 55) | struct shared_ptr_traits
      type shared_ptr_traits<void> (line 60) | struct shared_ptr_traits<void>
      type shared_ptr_traits<void const> (line 67) | struct shared_ptr_traits<void const>
      type shared_ptr_traits<void volatile> (line 72) | struct shared_ptr_traits<void volatile>
      type shared_ptr_traits<void const volatile> (line 77) | struct shared_ptr_traits<void const volatile>
      function sp_enable_shared_from_this (line 86) | void sp_enable_shared_from_this( shared_count const & pn, enable_sha...
      function sp_enable_shared_from_this (line 91) | inline void sp_enable_shared_from_this( shared_count const & /*pn*/,...
    class shared_ptr (line 106) | class shared_ptr
      method shared_ptr (line 119) | shared_ptr(): px(0), pn() // never throws in 1.30+
      method shared_ptr (line 124) | explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()...
      method shared_ptr (line 135) | shared_ptr(Y * p, D d): px(p), pn(p, d)
      method shared_ptr (line 144) | shared_ptr & operator=(shared_ptr const & r) // never throws
      method shared_ptr (line 153) | explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
      method shared_ptr (line 160) | shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
      method shared_ptr (line 165) | shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(sta...
      method shared_ptr (line 170) | shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(cons...
      method shared_ptr (line 175) | shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dy...
      method shared_ptr (line 184) | shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): p...
      method shared_ptr (line 195) | explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
      method shared_ptr (line 207) | shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
      method shared_ptr (line 219) | shared_ptr & operator=(std::auto_ptr<Y> & r)
      method reset (line 227) | void reset() // never throws in 1.30+
      method reset (line 232) | void reset(Y * p) // Y must be complete
      method reset (line 238) | void reset(Y * p, D d)
      method reference (line 243) | reference operator* () const // never throws
      method T (line 249) | T * operator-> () const // never throws
      method T (line 255) | T * get() const // never throws
      method unique (line 295) | bool unique() const // never throws
      method use_count (line 300) | long use_count() const // never throws
      method swap (line 305) | void swap(shared_ptr< T > & other) // never throws
      method _internal_less (line 311) | bool _internal_less(shared_ptr<Y> const & rhs) const
    function swap (line 354) | inline void swap(shared_ptr< T > & a, shared_ptr< T > & b)
    function static_pointer_cast (line 359) | shared_ptr< T > static_pointer_cast(shared_ptr<U> const & r)
    function const_pointer_cast (line 364) | shared_ptr< T > const_pointer_cast(shared_ptr<U> const & r)
    function dynamic_pointer_cast (line 369) | shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r)
    function shared_static_cast (line 376) | shared_ptr< T > shared_static_cast(shared_ptr<U> const & r)
    function shared_dynamic_cast (line 381) | shared_ptr< T > shared_dynamic_cast(shared_ptr<U> const & r)
    function shared_polymorphic_cast (line 386) | shared_ptr< T > shared_polymorphic_cast(shared_ptr<U> const & r)
    function shared_polymorphic_downcast (line 391) | shared_ptr< T > shared_polymorphic_downcast(shared_ptr<U> const & r)
    function T (line 399) | inline T * get_pointer(shared_ptr< T > const & p)
    function D (line 420) | D * get_deleter(shared_ptr< T > const & p)
    function D (line 428) | D * get_deleter(shared_ptr< T > const & p)

FILE: include/boost/serialization/detail/shared_ptr_nmt_132.hpp
  type boost (line 30) | namespace boost
    class shared_ptr (line 33) | class shared_ptr
      method shared_ptr (line 44) | explicit shared_ptr(T * p = 0): px(p)
      method shared_ptr (line 80) | shared_ptr(shared_ptr const & r): px(r.px)  // never throws
      method shared_ptr (line 86) | shared_ptr & operator=(shared_ptr const & r)
      method shared_ptr (line 94) | explicit shared_ptr(std::auto_ptr< T > & r)
      method shared_ptr (line 100) | shared_ptr & operator=(std::auto_ptr< T > & r)
      method reset (line 108) | void reset(T * p = 0)
      method T (line 114) | T & operator*() const  // never throws
      method T (line 120) | T * operator->() const  // never throws
      method T (line 126) | T * get() const  // never throws
      method use_count (line 131) | long use_count() const  // never throws
      method unique (line 136) | bool unique() const  // never throws
      method swap (line 141) | void swap(shared_ptr< T > & other)  // never throws
    function swap (line 168) | void swap(shared_ptr< T > & a, shared_ptr< T > & b)
    function T (line 175) | inline T * get_pointer(shared_ptr< T > const & p)

FILE: include/boost/serialization/detail/stack_constructor.hpp
  type boost (line 22) | namespace boost{
    type serialization (line 23) | namespace serialization {
      type detail (line 24) | namespace detail {
        type stack_allocate (line 29) | struct stack_allocate
          method T (line 31) | T * address() {
          method T (line 34) | T & reference() {
        type stack_construct (line 47) | struct stack_construct : public stack_allocate<T>
          method stack_construct (line 49) | stack_construct(Archive & ar, const unsigned int version){

FILE: include/boost/serialization/export.hpp
  type boost (line 45) | namespace boost {
    type archive (line 46) | namespace archive {
      type detail (line 47) | namespace detail {
        class basic_pointer_iserializer (line 49) | class basic_pointer_iserializer
        class basic_pointer_oserializer (line 50) | class basic_pointer_oserializer
        class pointer_iserializer (line 53) | class pointer_iserializer
        class pointer_oserializer (line 55) | class pointer_oserializer
        type export_impl (line 58) | struct export_impl
          method basic_pointer_iserializer (line 60) | static const basic_pointer_iserializer &
          method basic_pointer_oserializer (line 67) | static const basic_pointer_oserializer &
          method enable_load (line 73) | inline static void enable_load(mpl::false_) {}
          method enable_save (line 74) | inline static void enable_save(mpl::false_) {}
        type instantiate_function (line 80) | struct instantiate_function {}
        type ptr_serialization_support (line 83) | struct ptr_serialization_support
        function BOOST_DLLEXPORT (line 96) | BOOST_DLLEXPORT void
        type extra_detail (line 112) | namespace extra_detail {
          type guid_initializer (line 115) | struct guid_initializer
            method export_guid (line 117) | void export_guid(mpl::false_) const {
            method export_guid (line 123) | void export_guid(mpl::true_) const {
            method guid_initializer (line 125) | guid_initializer const & export_guid() const {
          type init_guid (line 137) | struct init_guid

FILE: include/boost/serialization/extended_type_info.hpp
  type boost (line 37) | namespace boost {
    type serialization (line 38) | namespace serialization {
      type void_cast_detail (line 40) | namespace void_cast_detail{
        class void_caster (line 41) | class void_caster
      class BOOST_SYMBOL_VISIBLE (line 44) | class BOOST_SYMBOL_VISIBLE
      type guid_defined (line 89) | struct guid_defined : boost::mpl::false_ {}
      type ext (line 91) | namespace ext {
        type guid_impl (line 93) | struct guid_impl

FILE: include/boost/serialization/extended_type_info_no_rtti.hpp
  type boost (line 47) | namespace boost {
    type serialization (line 48) | namespace serialization {
      type no_rtti_system (line 53) | namespace no_rtti_system {
        function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
      class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
        type action (line 78) | struct action {
          type defined (line 79) | struct defined {
          type undefined (line 84) | struct undefined {
        method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
        method extended_type_info (line 112) | const extended_type_info *
        method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 174) | struct extended_type_info_impl {
    type serialization (line 172) | namespace serialization {
      type no_rtti_system (line 53) | namespace no_rtti_system {
        function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
      class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
        type action (line 78) | struct action {
          type defined (line 79) | struct defined {
          type undefined (line 84) | struct undefined {
        method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
        method extended_type_info (line 112) | const extended_type_info *
        method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 174) | struct extended_type_info_impl {
  type boost (line 171) | namespace boost {
    type serialization (line 48) | namespace serialization {
      type no_rtti_system (line 53) | namespace no_rtti_system {
        function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
      class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
        type action (line 78) | struct action {
          type defined (line 79) | struct defined {
          type undefined (line 84) | struct undefined {
        method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
        method extended_type_info (line 112) | const extended_type_info *
        method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 174) | struct extended_type_info_impl {
    type serialization (line 172) | namespace serialization {
      type no_rtti_system (line 53) | namespace no_rtti_system {
        function extended_type_info_no_rtti_0 (line 57) | class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
      class extended_type_info_no_rtti (line 73) | class extended_type_info_no_rtti :
        type action (line 78) | struct action {
          type defined (line 79) | struct defined {
          type undefined (line 84) | struct undefined {
        method extended_type_info_no_rtti (line 103) | extended_type_info_no_rtti() :
        method extended_type_info (line 112) | const extended_type_info *
        method destroy (line 153) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 174) | struct extended_type_info_impl {

FILE: include/boost/serialization/extended_type_info_typeid.hpp
  type boost (line 48) | namespace boost {
    type serialization (line 49) | namespace serialization {
      type typeid_system (line 50) | namespace typeid_system {
        function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
      class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
        method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
        method extended_type_info (line 100) | const extended_type_info *
        method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 156) | struct extended_type_info_impl {
    type serialization (line 154) | namespace serialization {
      type typeid_system (line 50) | namespace typeid_system {
        function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
      class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
        method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
        method extended_type_info (line 100) | const extended_type_info *
        method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 156) | struct extended_type_info_impl {
  type boost (line 153) | namespace boost {
    type serialization (line 49) | namespace serialization {
      type typeid_system (line 50) | namespace typeid_system {
        function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
      class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
        method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
        method extended_type_info (line 100) | const extended_type_info *
        method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 156) | struct extended_type_info_impl {
    type serialization (line 154) | namespace serialization {
      type typeid_system (line 50) | namespace typeid_system {
        function extended_type_info_typeid_0 (line 52) | class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
      class extended_type_info_typeid (line 81) | class extended_type_info_typeid :
        method extended_type_info_typeid (line 86) | extended_type_info_typeid() :
        method extended_type_info (line 100) | const extended_type_info *
        method destroy (line 136) | void destroy(void const * const p) const BOOST_OVERRIDE {
      type extended_type_info_impl (line 156) | struct extended_type_info_impl {

FILE: include/boost/serialization/factory.hpp
  type std (line 26) | namespace std{
  type boost (line 32) | namespace boost {
    type serialization (line 33) | namespace serialization {
      function T (line 37) | T * factory(std::va_list){

FILE: include/boost/serialization/forward_list.hpp
  type boost (line 35) | namespace boost {
    type serialization (line 36) | namespace serialization {
      function save (line 39) | inline void save(
      type stl (line 51) | namespace stl {
        function collection_load_impl (line 58) | typename boost::disable_if<
      function load (line 88) | inline void load(
      function serialize (line 109) | inline void serialize(

FILE: include/boost/serialization/hash_collections_load_imp.hpp
  type boost (line 25) | namespace boost{
    type serialization (line 26) | namespace serialization {
      type stl (line 27) | namespace stl {
        function load_hash_collection (line 33) | inline void load_hash_collection(Archive & ar, Container &s)

FILE: include/boost/serialization/hash_collections_save_imp.hpp
  type boost (line 28) | namespace boost{
    type serialization (line 29) | namespace serialization {
      type stl (line 30) | namespace stl {
        function save_hash_collection (line 37) | inline void save_hash_collection(Archive & ar, const Container &s)

FILE: include/boost/serialization/hash_map.hpp
  type boost (line 30) | namespace boost {
    type serialization (line 31) | namespace serialization {
      type stl (line 33) | namespace stl {
        type archive_input_hash_map (line 37) | struct archive_input_hash_map
        type archive_input_hash_multimap (line 64) | struct archive_input_hash_multimap
      function save (line 97) | inline void save(
      function load (line 120) | inline void load(
      function serialize (line 151) | inline void serialize(
      function save (line 170) | inline void save(
      function load (line 193) | inline void load(
      function serialize (line 224) | inline void serialize(

FILE: include/boost/serialization/hash_set.hpp
  type boost (line 29) | namespace boost {
    type serialization (line 30) | namespace serialization {
      type stl (line 32) | namespace stl {
        type archive_input_hash_set (line 36) | struct archive_input_hash_set
        type archive_input_hash_multiset (line 56) | struct archive_input_hash_multiset
      function save (line 82) | inline void save(
      function load (line 104) | inline void load(
      function serialize (line 134) | inline void serialize(
      function save (line 152) | inline void save(
      function load (line 174) | inline void load(
      function serialize (line 204) | inline void serialize(

FILE: include/boost/serialization/is_bitwise_serializable.hpp
  type boost (line 27) | namespace boost {
    type serialization (line 28) | namespace serialization {
      type is_bitwise_serializable (line 30) | struct is_bitwise_serializable

FILE: include/boost/serialization/item_version_type.hpp
  type boost (line 17) | namespace boost {
    type serialization (line 18) | namespace serialization {
      class item_version_type (line 25) | class item_version_type {
        method item_version_type (line 31) | item_version_type(): t(0) {}
        method item_version_type (line 32) | explicit item_version_type(const unsigned int t_) : t(t_){
        method item_version_type (line 35) | item_version_type(const item_version_type & t_) :
        method item_version_type (line 38) | item_version_type & operator=(item_version_type rhs){

FILE: include/boost/serialization/level.hpp
  type boost (line 35) | namespace boost {
    type serialization (line 36) | namespace serialization {
      type basic_traits (line 38) | struct basic_traits
      type implementation_level_impl (line 42) | struct implementation_level_impl {
        type traits_class_level (line 44) | struct traits_class_level {
      type implementation_level (line 83) | struct implementation_level :
      type level_type (line 89) | enum level_type

FILE: include/boost/serialization/level_enum.hpp
  type boost (line 19) | namespace boost {
    type serialization (line 20) | namespace serialization {
      type level_type (line 26) | enum level_type

FILE: include/boost/serialization/library_version_type.hpp
  type boost (line 24) | namespace boost {
    type serialization (line 25) | namespace serialization {
      class library_version_type (line 36) | class library_version_type {
        method library_version_type (line 41) | library_version_type(): t(0) {}
        method library_version_type (line 42) | explicit library_version_type(const unsigned int & t_) : t(t_){
        method library_version_type (line 45) | library_version_type(const library_version_type & t_) :
        method library_version_type (line 48) | library_version_type & operator=(const library_version_type & rhs){

FILE: include/boost/serialization/list.hpp
  type boost (line 33) | namespace boost {
    type serialization (line 34) | namespace serialization {
      function save (line 37) | inline void save(
      function load (line 49) | inline void load(
      function serialize (line 70) | inline void serialize(

FILE: include/boost/serialization/map.hpp
  type boost (line 36) | namespace boost {
    type serialization (line 37) | namespace serialization {
      function load_map_collection (line 43) | inline void load_map_collection(Archive & ar, Container &s)
      function save (line 72) | inline void save(
      function load (line 84) | inline void load(
      function serialize (line 95) | inline void serialize(
      function save (line 105) | inline void save(
      function load (line 117) | inline void load(
      function serialize (line 128) | inline void serialize(

FILE: include/boost/serialization/nvp.hpp
  type boost (line 39) | namespace boost {
    type serialization (line 40) | namespace serialization {
      function save (line 43) | void save(
      function load (line 51) | void load(
      function serialize (line 60) | inline void serialize(
      type implementation_level<nvp< T > > (line 69) | struct implementation_level<nvp< T > >
      type implementation_level<const nvp< T > > (line 76) | struct implementation_level<const nvp< T > >
      type tracking_level<nvp< T > > (line 85) | struct tracking_level<nvp< T > >
      type tracking_level<const nvp< T > > (line 92) | struct tracking_level<const nvp< T > >
      type version<const nvp< T > > (line 102) | struct version<const nvp< T > > {
      type version<const nvp< T > > (line 107) | struct version<const nvp< T > > {
      type extended_type_info_impl<const nvp< T > > (line 114) | struct extended_type_info_impl<const nvp< T > > {
      type is_wrapper<const nvp<T> > (line 120) | struct is_wrapper<const nvp<T> > {
      type is_wrapper<nvp<T> > (line 124) | struct is_wrapper<nvp<T> > {

FILE: include/boost/serialization/optional.hpp
  type boost (line 33) | namespace boost {
    type serialization (line 34) | namespace serialization {
      type detail (line 35) | namespace detail {
        function save_impl (line 39) | void save_impl(
        function load_impl (line 63) | void load_impl(
      function save (line 92) | void save(
      function save (line 102) | void save(
      function load (line 112) | void load(
      function load (line 122) | void load(
      function serialize (line 132) | void serialize(
      function serialize (line 142) | void serialize(
      type version<boost::optional<T> > (line 152) | struct version<boost::optional<T> >{
      type version<std::optional<T> > (line 158) | struct version<std::optional<T> >{

FILE: include/boost/serialization/priority_queue.hpp
  type boost (line 32) | namespace boost {
    type serialization (line 33) | namespace serialization {
      type detail (line 34) | namespace detail{
        type priority_queue_save (line 37) | struct priority_queue_save : public STD::priority_queue<U, Contain...
        type priority_queue_load (line 44) | struct priority_queue_load : public STD::priority_queue<U, Contain...
      function serialize (line 54) | inline void serialize(

FILE: include/boost/serialization/queue.hpp
  type boost (line 32) | namespace boost {
    type serialization (line 33) | namespace serialization {
      type detail (line 34) | namespace detail {
        type queue_save (line 37) | struct queue_save : public STD::queue<U, C> {
        type queue_load (line 44) | struct queue_load : public STD::queue<U, C> {
      function serialize (line 54) | inline void serialize(

FILE: include/boost/serialization/scoped_ptr.hpp
  type boost (line 22) | namespace boost {
    type serialization (line 23) | namespace serialization {
      function save (line 26) | void save(
      function load (line 36) | void load(
      function serialize (line 47) | void serialize(

FILE: include/boost/serialization/serialization.hpp
  type boost (line 49) | namespace boost {
    type serialization (line 50) | namespace serialization {
      function serialize (line 56) | inline void serialize(
      function save_construct_data (line 64) | inline void save_construct_data(
      function load_construct_data (line 75) | inline void load_construct_data(
      function serialize_adl (line 103) | inline void serialize_adl(
      function save_construct_data_adl (line 113) | inline void save_construct_data_adl(
      function load_construct_data_adl (line 124) | inline void load_construct_data_adl(

FILE: include/boost/serialization/set.hpp
  type boost (line 34) | namespace boost {
    type serialization (line 35) | namespace serialization {
      function load_set_collection (line 38) | inline void load_set_collection(Archive & ar, Container &s)
      function save (line 67) | inline void save(
      function load (line 78) | inline void load(
      function serialize (line 89) | inline void serialize(
      function save (line 99) | inline void save(
      function load (line 111) | inline void load(
      function serialize (line 122) | inline void serialize(

FILE: include/boost/serialization/shared_ptr.hpp
  type boost (line 41) | namespace boost {
    type serialization (line 42) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 81) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 201) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 220) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
  type boost (line 80) | namespace boost {
    type serialization (line 42) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 81) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 201) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 220) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
  type boost (line 200) | namespace boost {
    type serialization (line 42) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 81) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 201) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 220) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
  type boost (line 219) | namespace boost {
    type serialization (line 42) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 81) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 201) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(
    type serialization (line 220) | namespace serialization{
      type version< ::boost::shared_ptr< T > > (line 44) | struct version< ::boost::shared_ptr< T > > {
      type tracking_level< ::boost::shared_ptr< T > > (line 55) | struct tracking_level< ::boost::shared_ptr< T > > {
      type null_deleter (line 83) | struct null_deleter {
      function save (line 96) | inline void save(
      function load (line 111) | inline void load(
      function load (line 147) | inline void load(
      function serialize (line 168) | inline void serialize(
      type version< ::std::shared_ptr< T > > (line 203) | struct version< ::std::shared_ptr< T > > {
      type tracking_level< ::std::shared_ptr< T > > (line 210) | struct tracking_level< ::std::shared_ptr< T > > {
      function save (line 226) | inline void save(
      function load (line 240) | inline void load(
      function serialize (line 262) | inline void serialize(

FILE: include/boost/serialization/shared_ptr_132.hpp
  type boost_132 (line 41) | namespace boost_132 {
    type serialization (line 42) | namespace serialization {
      type detail (line 43) | namespace detail {
        type null_deleter (line 45) | struct null_deleter {
  type boost (line 56) | namespace boost {
    type serialization (line 57) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
    type serialization (line 122) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
    type serialization (line 153) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
  type boost (line 121) | namespace boost {
    type serialization (line 57) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
    type serialization (line 122) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
    type serialization (line 153) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
  type boost (line 152) | namespace boost {
    type serialization (line 57) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
    type serialization (line 122) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(
    type serialization (line 153) | namespace serialization {
      function serialize (line 60) | inline void serialize(
      function save_construct_data (line 77) | inline void save_construct_data(
      function load_construct_data (line 88) | inline void load_construct_data(
      function save (line 125) | inline void save(
      function load (line 134) | inline void load(
      function save (line 156) | inline void save(
      function load (line 171) | inline void load(
      function serialize (line 186) | inline void serialize(

FILE: include/boost/serialization/shared_ptr_helper.hpp
  type boost_132 (line 35) | namespace boost_132 {
    class shared_ptr (line 36) | class shared_ptr
  type boost (line 38) | namespace boost {
    type serialization (line 39) | namespace serialization {
      class U (line 45) | class U
      class shared_ptr_helper (line 54) | class shared_ptr_helper {
        type null_deleter (line 67) | struct null_deleter {
        method append (line 94) | void
        type non_polymorphic (line 102) | struct non_polymorphic {
        type polymorphic (line 112) | struct polymorphic {
        method reset (line 125) | void reset(SPT< T > & s, T * t){
        method shared_ptr_helper (line 190) | shared_ptr_helper() :

FILE: include/boost/serialization/singleton.hpp
  type boost (line 53) | namespace boost {
    type serialization (line 54) | namespace serialization {
      class BOOST_SYMBOL_VISIBLE (line 100) | class BOOST_SYMBOL_VISIBLE
    function BOOST_DLLEXPORT (line 113) | BOOST_DLLEXPORT void unlock(){
    function BOOST_DLLEXPORT (line 116) | BOOST_DLLEXPORT bool is_locked(){
  function singleton_module (line 121) | static inline singleton_module & get_singleton_module(){
  type detail (line 126) | namespace detail {
    class singleton_wrapper (line 137) | class singleton_wrapper : public T
      method singleton_wrapper (line 147) | singleton_wrapper(){
      method is_destroyed (line 153) | static bool is_destroyed(){
  class singleton (line 161) | class singleton {
    method use (line 165) | static void use(T const &) {}
    method T (line 166) | static T & get_instance() {
    method BOOST_DLLEXPORT (line 188) | BOOST_DLLEXPORT singleton(){}
    method BOOST_DLLEXPORT (line 191) | BOOST_DLLEXPORT static T & get_mutable_instance(){
    method BOOST_DLLEXPORT (line 195) | BOOST_DLLEXPORT static const T & get_const_instance(){
    method BOOST_DLLEXPORT (line 198) | BOOST_DLLEXPORT static bool is_destroyed(){

FILE: include/boost/serialization/slist.hpp
  type boost (line 34) | namespace boost {
    type serialization (line 35) | namespace serialization {
      function save (line 38) | inline void save(
      type stl (line 49) | namespace stl {
        function collection_load_impl (line 56) | typename boost::disable_if<
      function load (line 86) | inline void load(
      function serialize (line 129) | inline void serialize(

FILE: include/boost/serialization/smart_cast.hpp
  type boost (line 61) | namespace boost {
    type serialization (line 62) | namespace serialization {
      type smart_cast_impl (line 63) | namespace smart_cast_impl {
        type reference (line 66) | struct reference {
          type polymorphic (line 68) | struct polymorphic {
            type linear (line 70) | struct linear {
              method T (line 72) | static T cast(U & u){
            type cross (line 77) | struct cross {
              method T (line 79) | static T cast(U & u){
            method T (line 85) | static T cast(U & u){
          type non_polymorphic (line 118) | struct non_polymorphic {
            method T (line 120) | static T cast(U & u){
          method T (line 125) | static T cast(U & u){
        type pointer (line 136) | struct pointer {
          type polymorphic (line 138) | struct polymorphic {
            type linear (line 143) | struct linear {
              method T (line 145) | static T cast(U * u){
            type cross (line 150) | struct cross {
              method T (line 152) | static T cast(U * u){
            method T (line 162) | static T cast(U * u){
            method T (line 183) | static T cast(U * u){
          type non_polymorphic (line 193) | struct non_polymorphic {
            method T (line 195) | static T cast(U * u){
          method T (line 201) | static T cast(U * u){
        type void_pointer (line 213) | struct void_pointer {
          method TPtr (line 215) | static TPtr cast(UPtr uptr){
        type error (line 221) | struct error {
          method T (line 226) | static T cast(U){
      function T (line 240) | T smart_cast(U u) {
      function T (line 268) | T smart_cast_reference(U & u) {

FILE: include/boost/serialization/split_free.hpp
  type boost (line 24) | namespace boost {
    type archive (line 25) | namespace archive {
      type detail (line 26) | namespace detail {
        class interface_oarchive (line 27) | class interface_oarchive
        class interface_iarchive (line 28) | class interface_iarchive
    type serialization (line 32) | namespace serialization {
      type free_saver (line 35) | struct free_saver {
        method invoke (line 36) | static void invoke(
      type free_loader (line 48) | struct free_loader {
        method invoke (line 49) | static void invoke(
      function split_free (line 62) | inline void split_free(

FILE: include/boost/serialization/split_member.hpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      type detail (line 27) | namespace detail {
        class interface_oarchive (line 28) | class interface_oarchive
        class interface_iarchive (line 29) | class interface_iarchive
    type serialization (line 33) | namespace serialization {
      type detail (line 34) | namespace detail {
        type member_saver (line 37) | struct member_saver {
          method invoke (line 38) | static void invoke(
        type member_loader (line 48) | struct member_loader {
          method invoke (line 49) | static void invoke(
      function split_member (line 61) | inline void split_member(

FILE: include/boost/serialization/stack.hpp
  type boost (line 32) | namespace boost {
    type serialization (line 33) | namespace serialization {
      type detail (line 34) | namespace detail{
        type stack_save (line 37) | struct stack_save : public STD::stack<U, C> {
        type stack_load (line 44) | struct stack_load : public STD::stack<U, C> {
      function serialize (line 54) | inline void serialize(

FILE: include/boost/serialization/state_saver.hpp
  type serialization (line 39) | namespace serialization {
    class state_saver (line 46) | class state_saver : private boost::noncopyable
      type restore (line 52) | struct restore {
        method invoke (line 53) | static void invoke(T & previous_ref, const T & previous_value){
      type restore_with_exception (line 58) | struct restore_with_exception {
        method invoke (line 59) | static void invoke(T & previous_ref, const T & previous_value){
        method BOOST_CATCH (line 63) | BOOST_CATCH(::std::exception &) {
        method state_saver (line 71) | state_saver(

FILE: include/boost/serialization/static_warning.hpp
  type boost (line 72) | namespace boost {
    type serialization (line 73) | namespace serialization {
      type BOOST_SERIALIZATION_STATIC_WARNING_LINE (line 76) | struct BOOST_SERIALIZATION_STATIC_WARNING_LINE{}
      type static_warning_test (line 79) | struct static_warning_test{
      type BOOST_SERIALIZATION_SS (line 92) | struct BOOST_SERIALIZATION_SS {}

FILE: include/boost/serialization/std_variant.hpp
  type boost (line 33) | namespace boost {
    type serialization (line 34) | namespace serialization {
      type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
        method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
      type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
        method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type mp (line 80) | namespace mp {
        type detail (line 81) | namespace detail {
          type front_impl (line 83) | struct front_impl
          type pop_front_impl (line 91) | struct pop_front_impl
        type typelist (line 100) | struct typelist {}
      type variant_impl (line 110) | struct variant_impl
        method load (line 113) | static void load (
      type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
        method load (line 142) | static void load (
      function load (line 151) | void load(
      function serialize (line 169) | inline void serialize(
      function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
    type serialization (line 190) | namespace serialization {
      type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
        method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
      type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
        method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type mp (line 80) | namespace mp {
        type detail (line 81) | namespace detail {
          type front_impl (line 83) | struct front_impl
          type pop_front_impl (line 91) | struct pop_front_impl
        type typelist (line 100) | struct typelist {}
      type variant_impl (line 110) | struct variant_impl
        method load (line 113) | static void load (
      type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
        method load (line 142) | static void load (
      function load (line 151) | void load(
      function serialize (line 169) | inline void serialize(
      function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
  type front_impl<Seq<T, Ts...>> (line 86) | struct front_impl<Seq<T, Ts...>> {
  type pop_front_impl<Seq<T, Ts...>> (line 94) | struct pop_front_impl<Seq<T, Ts...>> {
  type boost (line 189) | namespace boost {
    type serialization (line 34) | namespace serialization {
      type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
        method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
      type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
        method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type mp (line 80) | namespace mp {
        type detail (line 81) | namespace detail {
          type front_impl (line 83) | struct front_impl
          type pop_front_impl (line 91) | struct pop_front_impl
        type typelist (line 100) | struct typelist {}
      type variant_impl (line 110) | struct variant_impl
        method load (line 113) | static void load (
      type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
        method load (line 142) | static void load (
      function load (line 151) | void load(
      function serialize (line 169) | inline void serialize(
      function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
    type serialization (line 190) | namespace serialization {
      type std_variant_save_visitor (line 37) | struct std_variant_save_visitor
        method std_variant_save_visitor (line 39) | std_variant_save_visitor(Archive& ar) :
      type std_variant_load_visitor (line 53) | struct std_variant_load_visitor
        method std_variant_load_visitor (line 55) | std_variant_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type mp (line 80) | namespace mp {
        type detail (line 81) | namespace detail {
          type front_impl (line 83) | struct front_impl
          type pop_front_impl (line 91) | struct pop_front_impl
        type typelist (line 100) | struct typelist {}
      type variant_impl (line 110) | struct variant_impl
        method load (line 113) | static void load (
      type variant_impl<0, Seq> (line 139) | struct variant_impl<0, Seq>
        method load (line 142) | static void load (
      function load (line 151) | void load(
      function serialize (line 169) | inline void serialize(
      function serialize (line 179) | void serialize(Archive &, std::monostate &, const unsigned int /*ver...
  type tracking_level<
    std::variant<Types...>
> (line 193) | struct tracking_level<

FILE: include/boost/serialization/throw_exception.hpp
  type boost (line 24) | namespace boost {
    type serialization (line 25) | namespace serialization {
      function BOOST_NORETURN (line 29) | BOOST_NORETURN inline void throw_exception(std::exception const & e) {
      function BOOST_NORETURN (line 36) | BOOST_NORETURN inline void throw_exception(E const & e){

FILE: include/boost/serialization/tracking.hpp
  type boost (line 34) | namespace boost {
    type serialization (line 35) | namespace serialization {
      type basic_traits (line 37) | struct basic_traits
      type tracking_level_impl (line 41) | struct tracking_level_impl {
        type traits_class_tracking (line 43) | struct traits_class_tracking {
      type tracking_level (line 74) | struct tracking_level :
      type tracking_type (line 79) | enum tracking_type
      type tracking_type (line 80) | enum tracking_type

FILE: include/boost/serialization/tracking_enum.hpp
  type boost (line 19) | namespace boost {
    type serialization (line 20) | namespace serialization {
      type tracking_type (line 27) | enum tracking_type

FILE: include/boost/serialization/traits.hpp
  type boost (line 35) | namespace boost {
    type serialization (line 36) | namespace serialization {
      type basic_traits (line 39) | struct basic_traits {}
      type extended_type_info_impl (line 42) | struct extended_type_info_impl
      type traits (line 52) | struct traits : public basic_traits {

FILE: include/boost/serialization/type_info_implementation.hpp
  type boost (line 29) | namespace boost {
    type serialization (line 30) | namespace serialization {
      type type_info_implementation (line 35) | struct type_info_implementation {
        type traits_class_typeinfo_implementation (line 37) | struct traits_class_typeinfo_implementation {

FILE: include/boost/serialization/unique_ptr.hpp
  type boost (line 22) | namespace boost {
    type serialization (line 23) | namespace serialization {
      function save (line 30) | inline void save(
      function load (line 42) | inline void load(
      function serialize (line 56) | inline void serialize(

FILE: include/boost/serialization/unordered_collections_load_imp.hpp
  type std (line 27) | namespace std{
  type boost (line 39) | namespace boost{
    type serialization (line 40) | namespace serialization {
      type stl (line 41) | namespace stl {
        function load_unordered_collection (line 47) | inline void load_unordered_collection(Archive & ar, Container &s)

FILE: include/boost/serialization/unordered_collections_save_imp.hpp
  type boost (line 30) | namespace boost{
    type serialization (line 31) | namespace serialization {
      type stl (line 32) | namespace stl {
        function save_unordered_collection (line 39) | inline void save_unordered_collection(Archive & ar, const Containe...

FILE: include/boost/serialization/unordered_map.hpp
  type boost (line 31) | namespace boost {
    type serialization (line 32) | namespace serialization {
      function save (line 42) | inline void save(
      function load (line 61) | inline void load(
      function serialize (line 86) | inline void serialize(
      function save (line 103) | inline void save(
      function load (line 122) | inline void load(
      function serialize (line 147) | inline void serialize(

FILE: include/boost/serialization/unordered_set.hpp
  type boost (line 29) | namespace boost {
    type serialization (line 30) | namespace serialization {
      function save (line 39) | inline void save(
      function load (line 59) | inline void load(
      function serialize (line 87) | inline void serialize(
      function save (line 105) | inline void save(
      function load (line 125) | inline void load(
      function serialize (line 151) | inline void serialize(

FILE: include/boost/serialization/utility.hpp
  type boost (line 28) | namespace boost {
    type serialization (line 29) | namespace serialization {
      function serialize (line 33) | inline void serialize(
      type is_bitwise_serializable<std::pair<T,U> > (line 48) | struct is_bitwise_serializable<std::pair<T,U> >

FILE: include/boost/serialization/valarray.hpp
  type boost (line 37) | namespace boost {
    type serialization (line 38) | namespace serialization {
      function save (line 44) | void save( Archive & ar, const STD::valarray<U> &t, const unsigned i...
      function load (line 58) | void load( Archive & ar, STD::valarray<U> &t,  const unsigned int /*...
      function serialize (line 75) | inline void serialize( Archive & ar, STD::valarray<U> & t, const uns...

FILE: include/boost/serialization/variant.hpp
  class T (line 61) | class T
  function visit (line 62) | typename Visitor::result_type visit(
  class T (line 68) | class T
  function visit (line 69) | typename Visitor::result_type visit(
  type boost (line 77) | namespace boost {
    type serialization (line 78) | namespace serialization {
      type variant_save_visitor (line 81) | struct variant_save_visitor :
        method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
      class T (line 95) | class T
      function save (line 96) | void save(
      function save (line 109) | void save(
      function save (line 123) | void save(
      type variant_impl (line 136) | struct variant_impl {
        type load_null (line 138) | struct load_null {
          method invoke (line 140) | static void invoke(
        type load_member (line 148) | struct load_member {
          method invoke (line 150) | static void invoke(
        method load_impl (line 175) | static void load_impl(
      class T (line 189) | class T
      function load (line 190) | void load(
      function load (line 211) | void load(
      function load (line 233) | void load(
      class T (line 253) | class T
      function serialize (line 254) | inline void serialize(
      function serialize (line 264) | inline void serialize(
      function serialize (line 275) | inline void serialize(
      class T (line 292) | class T
      type tracking_level<
    variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
    type serialization (line 290) | namespace serialization {
      type variant_save_visitor (line 81) | struct variant_save_visitor :
        method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
      class T (line 95) | class T
      function save (line 96) | void save(
      function save (line 109) | void save(
      function save (line 123) | void save(
      type variant_impl (line 136) | struct variant_impl {
        type load_null (line 138) | struct load_null {
          method invoke (line 140) | static void invoke(
        type load_member (line 148) | struct load_member {
          method invoke (line 150) | static void invoke(
        method load_impl (line 175) | static void load_impl(
      class T (line 189) | class T
      function load (line 190) | void load(
      function load (line 211) | void load(
      function load (line 233) | void load(
      class T (line 253) | class T
      function serialize (line 254) | inline void serialize(
      function serialize (line 264) | inline void serialize(
      function serialize (line 275) | inline void serialize(
      class T (line 292) | class T
      type tracking_level<
    variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
  type boost (line 289) | namespace boost {
    type serialization (line 78) | namespace serialization {
      type variant_save_visitor (line 81) | struct variant_save_visitor :
        method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
      class T (line 95) | class T
      function save (line 96) | void save(
      function save (line 109) | void save(
      function save (line 123) | void save(
      type variant_impl (line 136) | struct variant_impl {
        type load_null (line 138) | struct load_null {
          method invoke (line 140) | static void invoke(
        type load_member (line 148) | struct load_member {
          method invoke (line 150) | static void invoke(
        method load_impl (line 175) | static void load_impl(
      class T (line 189) | class T
      function load (line 190) | void load(
      function load (line 211) | void load(
      function load (line 233) | void load(
      class T (line 253) | class T
      function serialize (line 254) | inline void serialize(
      function serialize (line 264) | inline void serialize(
      function serialize (line 275) | inline void serialize(
      class T (line 292) | class T
      type tracking_level<
    variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
    type serialization (line 290) | namespace serialization {
      type variant_save_visitor (line 81) | struct variant_save_visitor :
        method variant_save_visitor (line 84) | variant_save_visitor(Archive& ar) :
      class T (line 95) | class T
      function save (line 96) | void save(
      function save (line 109) | void save(
      function save (line 123) | void save(
      type variant_impl (line 136) | struct variant_impl {
        type load_null (line 138) | struct load_null {
          method invoke (line 140) | static void invoke(
        type load_member (line 148) | struct load_member {
          method invoke (line 150) | static void invoke(
        method load_impl (line 175) | static void load_impl(
      class T (line 189) | class T
      function load (line 190) | void load(
      function load (line 211) | void load(
      function load (line 233) | void load(
      class T (line 253) | class T
      function serialize (line 254) | inline void serialize(
      function serialize (line 264) | inline void serialize(
      function serialize (line 275) | inline void serialize(
      class T (line 292) | class T
      type tracking_level<
    variant<BOOST_VARIANT_ENUM_PARAMS(T)>
> (line 293) | struct tracking_level<
  type tracking_level<
    std::variant<Types...>
> (line 303) | struct tracking_level<

FILE: include/boost/serialization/variant2.hpp
  type boost (line 33) | namespace boost {
    type serialization (line 34) | namespace serialization {
      type variant2_save_visitor (line 37) | struct variant2_save_visitor
        method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
      type variant2_load_visitor (line 53) | struct variant2_load_visitor
        method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type variant_impl (line 80) | struct variant_impl
        method load (line 83) | static void load (
      type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
        method load (line 112) | static void load (
      function load (line 121) | void load(
      function serialize (line 139) | inline void serialize(
      function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
    type serialization (line 160) | namespace serialization {
      type variant2_save_visitor (line 37) | struct variant2_save_visitor
        method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
      type variant2_load_visitor (line 53) | struct variant2_load_visitor
        method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type variant_impl (line 80) | struct variant_impl
        method load (line 83) | static void load (
      type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
        method load (line 112) | static void load (
      function load (line 121) | void load(
      function serialize (line 139) | inline void serialize(
      function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
  type boost (line 159) | namespace boost {
    type serialization (line 34) | namespace serialization {
      type variant2_save_visitor (line 37) | struct variant2_save_visitor
        method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
      type variant2_load_visitor (line 53) | struct variant2_load_visitor
        method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type variant_impl (line 80) | struct variant_impl
        method load (line 83) | static void load (
      type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
        method load (line 112) | static void load (
      function load (line 121) | void load(
      function serialize (line 139) | inline void serialize(
      function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
    type serialization (line 160) | namespace serialization {
      type variant2_save_visitor (line 37) | struct variant2_save_visitor
        method variant2_save_visitor (line 39) | variant2_save_visitor(Archive& ar) :
      type variant2_load_visitor (line 53) | struct variant2_load_visitor
        method variant2_load_visitor (line 55) | variant2_load_visitor(Archive& ar) :
      function save (line 68) | void save(
      type variant_impl (line 80) | struct variant_impl
        method load (line 83) | static void load (
      type variant_impl<Seq> (line 109) | struct variant_impl<Seq>
        method load (line 112) | static void load (
      function load (line 121) | void load(
      function serialize (line 139) | inline void serialize(
      function serialize (line 149) | void serialize(Archive &ar, variant2::monostate &, const unsigned in...
  type tracking_level<
    variant2::variant<Types...>
> (line 163) | struct tracking_level<

FILE: include/boost/serialization/vector.hpp
  type boost (line 52) | namespace boost {
    type serialization (line 53) | namespace serialization {
      function save (line 61) | inline void save(
      function load (line 73) | inline void load(
      function save (line 96) | inline void save(
      function load (line 113) | inline void load(
      function save (line 137) | inline void save(
      function load (line 150) | inline void load(
      function serialize (line 172) | inline void serialize(
      function save (line 183) | inline void save(
      function load (line 199) | inline void load(
      function serialize (line 218) | inline void serialize(

FILE: include/boost/serialization/version.hpp
  type boost (line 28) | namespace boost {
    type serialization (line 29) | namespace serialization {
      type basic_traits (line 31) | struct basic_traits
      type version (line 36) | struct version
        type traits_class_version (line 39) | struct traits_class_version {

FILE: include/boost/serialization/void_cast.hpp
  type boost (line 41) | namespace boost {
    type serialization (line 42) | namespace serialization {
      class extended_type_info (line 44) | class extended_type_info
      type void_cast_detail (line 91) | namespace void_cast_detail {
        class BOOST_SYMBOL_VISIBLE (line 93) | class BOOST_SYMBOL_VISIBLE
        function void_caster (line 128) | const void_caster & operator*(){
        function void_caster (line 135) | void_caster(
        function void_caster_primitive (line 155) | class BOOST_SYMBOL_VISIBLE void_caster_primitive :
      function void_caster_virtual_base (line 206) | class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
    function void_caster_base (line 251) | struct BOOST_SYMBOL_VISIBLE void_caster_base :
  function BOOST_DLLEXPORT (line 269) | BOOST_DLLEXPORT
  class BOOST_SYMBOL_VISIBLE (line 288) | class BOOST_SYMBOL_VISIBLE

FILE: include/boost/serialization/void_cast_fwd.hpp
  type boost (line 23) | namespace boost {
    type serialization (line 24) | namespace serialization {
      type void_cast_detail (line 25) | namespace void_cast_detail{
        class void_caster (line 26) | class void_caster

FILE: include/boost/serialization/weak_ptr.hpp
  type boost (line 22) | namespace boost {
    type serialization (line 23) | namespace serialization{
      function save (line 26) | inline void save(
      function load (line 36) | inline void load(
      function serialize (line 47) | inline void serialize(
      function save (line 65) | inline void save(
      function load (line 75) | inline void load(
      function serialize (line 86) | inline void serialize(
    type serialization (line 62) | namespace serialization{
      function save (line 26) | inline void save(
      function load (line 36) | inline void load(
      function serialize (line 47) | inline void serialize(
      function save (line 65) | inline void save(
      function load (line 75) | inline void load(
      function serialize (line 86) | inline void serialize(
  type boost (line 61) | namespace boost {
    type serialization (line 23) | namespace serialization{
      function save (line 26) | inline void save(
      function load (line 36) | inline void load(
      function serialize (line 47) | inline void serialize(
      function save (line 65) | inline void save(
      function load (line 75) | inline void load(
      function serialize (line 86) | inline void serialize(
    type serialization (line 62) | namespace serialization{
      function save (line 26) | inline void save(
      function load (line 36) | inline void load(
      function serialize (line 47) | inline void serialize(
      function save (line 65) | inline void save(
      function load (line 75) | inline void load(
      function serialize (line 86) | inline void serialize(

FILE: include/boost/serialization/wrapper.hpp
  type boost (line 14) | namespace boost { namespace serialization {
    type serialization (line 14) | namespace serialization {
      type wrapper_traits (line 29) | struct wrapper_traits :
      type is_wrapper_impl (line 34) | struct is_wrapper_impl :
      type is_wrapper (line 43) | struct is_wrapper {

FILE: performance/peformance_array.cpp
  type std (line 15) | namespace std{
  type array_equal_to (line 36) | struct array_equal_to //: public std::binary_function<T, T, bool>
  function test_array (line 62) | int test_array(T)
  function BOOST_CATCH (line 102) | BOOST_CATCH (boost::archive::archive_exception ae){}
  function test_main (line 109) | int test_main( int /* argc */, char* /* argv */[] )

FILE: performance/performance_binary.cpp
  type std (line 17) | namespace std{
  class A (line 34) | class A {
    method serialize (line 41) | void serialize(Archive & ar, const unsigned int /* file_version */){
  function test_main (line 67) | int test_main( int /* argc */, char* /* argv */[] )

FILE: performance/performance_codecvt_null.cpp
  type std (line 24) | namespace std{
  type test_data (line 37) | struct test_data
  function test_main (line 71) | int test_main( int /* argc */, char* /* argv */[] ) {

FILE: performance/performance_iterators.cpp
  type std (line 17) | namespace std{
  function test_wchar_from_mb (line 41) | void test_wchar_from_mb(const wchar_t *la, const char * a, const unsigne...
  function test_mb_from_wchar (line 52) | void test_mb_from_wchar(const char * a, const wchar_t *la, const unsigne...
  function test_xml_escape (line 66) | void test_xml_escape(
  function test_xml_unescape (line 83) | void test_xml_unescape(
  function test_transform_width (line 102) | void test_transform_width(unsigned int size){
  function test_stream_iterators (line 144) | void test_stream_iterators(
  function test_main (line 160) | int

FILE: performance/performance_iterators_base64.cpp
  type std (line 21) | namespace std{
  function test_base64 (line 40) | void test_base64(){
  function test_main (line 92) | int

FILE: performance/performance_no_rtti.cpp
  type std (line 22) | namespace std{
  class polymorphic_base (line 45) | class polymorphic_base
    method serialize (line 49) | void serialize(Archive & /* ar */, const unsigned int /* file_version ...
  class polymorphic_derived1 (line 64) | class polymorphic_derived1 : public polymorphic_base
    method serialize (line 68) | void serialize(Archive &ar, const unsigned int  /* file_version */){
  class polymorphic_derived2 (line 88) | class polymorphic_derived2 : public polymorphic_base
    method serialize (line 92) | void serialize(Archive &ar, const unsigned int /* file_version */){
  function save_derived (line 116) | void save_derived(const char *testfile)
  function load_derived (line 140) | void load_derived(const char *testfile)
  function test_main (line 208) | int

FILE: performance/performance_polymorphic.cpp
  type std (line 16) | namespace std{
  function test_main (line 50) | int test_main(int /* argc */, char * /* argv */ [])

FILE: performance/performance_simple_class.cpp
  type std (line 19) | namespace std{
  function test_main (line 35) | int

FILE: performance/performance_utf8_codecvt.cpp
  type std (line 20) | namespace std{
  type std (line 27) | namespace std{ using ::wcslen; }
  type test_data (line 38) | struct test_data
  function test_main (line 98) | int

FILE: performance/performance_vector.cpp
  type std (line 16) | namespace std{
  function test_vector (line 33) | int test_vector(T)
  function test_main (line 58) | int test_main( int /* argc */, char* /* argv */[] )

FILE: performance/xml/harness.hpp
  type std (line 30) | namespace std {
  type boost (line 54) | namespace boost {
    type archive (line 55) | namespace archive {
      type xml (line 56) | namespace xml {
        function T (line 60) | T
        function save_archive (line 80) | std::string
        function restore_archive (line 99) | std::pair<double, T>
        class result_set_exception (line 115) | class result_set_exception: public virtual archive_exception {
          type exception_code (line 117) | enum exception_code {
          method result_set_exception (line 121) | result_set_exception (exception_code c = invalid_archive_metadat...
        type entry (line 137) | struct entry {
          method serialize (line 143) | void serialize (ARC& ar, const unsigned int) {
          method entry (line 150) | entry (void) { }
          method entry (line 152) | entry (std::string type, std::size_t size, double data):
        type result_set (line 156) | struct result_set {
          method serialize (line 162) | void serialize (ARC& ar, const unsigned int) {
          method result_set (line 173) | result_set (void):
          method result_set (line 177) | result_set (std::list<entry> entries):

FILE: performance/xml/high_resolution_timer.hpp
  type boost (line 24) | namespace boost {
    type archive (line 25) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 122) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 206) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 319) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 457) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
  type boost (line 121) | namespace boost {
    type archive (line 25) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 122) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 206) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 319) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 457) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
  type boost (line 205) | namespace boost {
    type archive (line 25) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 122) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 206) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 319) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 457) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
  type boost (line 318) | namespace boost {
    type archive (line 25) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 122) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 206) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 319) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 457) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
  type boost (line 456) | namespace boost {
    type archive (line 25) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 122) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 206) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 319) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
    type archive (line 457) | namespace archive {
      type xml (line 26) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 123) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 207) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 320) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
      type xml (line 458) | namespace xml {
        class high_resolution_timer (line 34) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 131) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 214) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        class high_resolution_timer (line 333) | class high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()
        type high_resolution_timer (line 460) | struct high_resolution_timer
          method high_resolution_timer (line 37) | high_resolution_timer()
          method high_resolution_timer (line 42) | high_resolution_timer(double t)
          method high_resolution_timer (line 51) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 56) | static double now()
          method restart (line 72) | void restart()
          method elapsed (line 77) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 90) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 100) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 134) | high_resolution_timer()
          method high_resolution_timer (line 142) | high_resolution_timer(double t)
          method high_resolution_timer (line 148) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 153) | static double now()
          method restart (line 161) | void restart()
          method elapsed (line 166) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 179) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 184) | double elapsed_min() const            // return minimum value fo...
          method high_resolution_timer (line 217) | high_resolution_timer()
          method high_resolution_timer (line 227) | high_resolution_timer(double t)
          method high_resolution_timer (line 236) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 242) | static double now()
          method restart (line 253) | void restart()
          method elapsed (line 260) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 276) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 284) | double elapsed_min() const            // return minimum value fo...
          method unsigned_diff (line 337) | static inline double unsigned_diff(const U &a, const U &b)
          method elapsed (line 350) | double elapsed(const timeval &t1, const timeval &t0) const
          method high_resolution_timer (line 366) | high_resolution_timer()
          method high_resolution_timer (line 374) | high_resolution_timer(double t)
          method high_resolution_timer (line 380) | high_resolution_timer(high_resolution_timer const& rhs)
          method now (line 385) | static double now()
          method restart (line 399) | void restart()
          method elapsed (line 405) | double elapsed() const                  // return elapsed time i...
          method elapsed_max (line 413) | double elapsed_max() const   // return estimated maximum value f...
          method elapsed_min (line 418) | double elapsed_min() const            // return minimum value fo...
          method now (line 463) | static double now()

FILE: performance/xml/node.hpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      type xml (line 27) | namespace xml {
        type unused_type (line 29) | struct unused_type { }
        type node (line 36) | struct node
          method serialize (line 45) | void serialize (ARC& ar, const unsigned int) {
        type node (line 41) | struct node {
          method serialize (line 45) | void serialize (ARC& ar, const unsigned int) {

FILE: src/archive_exception.cpp
  type boost (line 23) | namespace boost {
    type archive (line 24) | namespace archive {
    function BOOST_ARCHIVE_DECL (line 140) | BOOST_ARCHIVE_DECL
    function BOOST_ARCHIVE_DECL (line 143) | BOOST_ARCHIVE_DECL const char *

FILE: src/basic_archive.cpp
  type boost (line 38) | namespace boost {
    type archive (line 39) | namespace archive {
      function BOOST_SYMBOL_VISIBLE (line 45) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 88) | BOOST_SYMBOL_VISIBLE boost::serialization::library_version_type

FILE: src/basic_iarchive.cpp
  type std (line 21) | namespace std{
  type boost (line 49) | namespace boost {
    type archive (line 50) | namespace archive {
      type detail (line 51) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type
      type detail (line 528) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type
    type archive (line 527) | namespace archive {
      type detail (line 51) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type
      type detail (line 528) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type
  type boost (line 526) | namespace boost {
    type archive (line 50) | namespace archive {
      type detail (line 51) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type
      type detail (line 528) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type
    type archive (line 527) | namespace archive {
      type detail (line 51) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type
      type detail (line 528) | namespace detail {
        class basic_iarchive_impl (line 53) | class basic_iarchive_impl {
          type aobject (line 61) | struct aobject
            method aobject (line 66) | aobject(
            method aobject (line 74) | aobject() :
          type moveable_objects (line 85) | struct moveable_objects {
            method moveable_objects (line 90) | moveable_objects() :
          type cobject_type (line 105) | struct cobject_type
            method cobject_type (line 109) | cobject_type(
            method cobject_type (line 116) | cobject_type(const cobject_type & rhs) :
          class cobject_id (line 134) | class cobject_id
            method cobject_id (line 137) | cobject_id & operator=(const cobject_id & rhs){
            method cobject_id (line 151) | cobject_id(const basic_iserializer & bis_) :
            method cobject_id (line 158) | cobject_id(const cobject_id &rhs):
          type pending (line 172) | struct pending {
            method pending (line 176) | pending() :
          method basic_iarchive_impl (line 183) | basic_iarchive_impl(unsigned int flags) :
          method set_library_version (line 187) | void set_library_version(library_version_type archive_library_ve...
          method load (line 206) | void load(basic_iarchive & ar, T & t){
          method next_object_pointer (line 211) | void
        function class_id_type (line 307) | inline class_id_type
        function basic_pointer_iserializer (line 415) | inline const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 530) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 540) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 544) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 549) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 557) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 566) | BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
        function BOOST_ARCHIVE_DECL (line 578) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 583) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 589) | BOOST_ARCHIVE_DECL boost::serialization::library_version_type

FILE: src/basic_iserializer.cpp
  type boost (line 17) | namespace boost {
    type archive (line 18) | namespace archive {
      type detail (line 19) | namespace detail {
        function BOOST_ARCHIVE_DECL (line 29) | BOOST_ARCHIVE_DECL

FILE: src/basic_oarchive.cpp
  type boost (line 44) | namespace boost {
    type archive (line 45) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &
      type detail (line 405) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &
    type archive (line 404) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &
      type detail (line 405) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &
  type boost (line 403) | namespace boost {
    type archive (line 45) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &
      type detail (line 405) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &
    type archive (line 404) | namespace archive {
      type detail (line 46) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &
      type detail (line 405) | namespace detail {
        class basic_oarchive_impl (line 48) | class basic_oarchive_impl {
          type aobject (line 55) | struct aobject
            method aobject (line 71) | aobject(
            method aobject (line 80) | aobject() : address(NULL){}
          type cobject_type (line 89) | struct cobject_type
            method cobject_type (line 94) | cobject_type(
            method cobject_type (line 102) | cobject_type(const basic_oserializer & bos) :
            method cobject_type (line 106) | cobject_type(
          method basic_oarchive_impl (line 135) | basic_oarchive_impl(unsigned int flags) :
        function basic_oserializer (line 166) | inline const basic_oserializer *
        function BOOST_ARCHIVE_DECL (line 412) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 416) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 424) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 432) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 437) | BOOST_ARCHIVE_DECL library_version_type
        function BOOST_ARCHIVE_DECL (line 447) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 451) | BOOST_ARCHIVE_DECL helper_collection &

FILE: src/basic_oserializer.cpp
  type boost (line 17) | namespace boost {
    type archive (line 18) | namespace archive {
      type detail (line 19) | namespace detail {
        function BOOST_ARCHIVE_DECL (line 29) | BOOST_ARCHIVE_DECL

FILE: src/basic_pointer_iserializer.cpp
  type boost (line 15) | namespace boost {
    type archive (line 16) | namespace archive {
      type detail (line 17) | namespace detail {
        function BOOST_ARCHIVE_DECL (line 19) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 26) | BOOST_ARCHIVE_DECL

FILE: src/basic_pointer_oserializer.cpp
  type boost (line 15) | namespace boost {
    type archive (line 16) | namespace archive {
      type detail (line 17) | namespace detail {
        function BOOST_ARCHIVE_DECL (line 19) | BOOST_ARCHIVE_DECL
        function BOOST_ARCHIVE_DECL (line 26) | BOOST_ARCHIVE_DECL

FILE: src/basic_serializer_map.cpp
  type boost (line 29) | namespace boost {
    type serialization (line 30) | namespace serialization {
      class extended_type_info (line 31) | class extended_type_info
    type archive (line 33) | namespace archive {
      type detail (line 34) | namespace detail {
        function BOOST_ARCHIVE_DECL (line 43) | BOOST_ARCHIVE_DECL bool
        function BOOST_ARCHIVE_DECL (line 75) | BOOST_ARCHIVE_DECL void
        function BOOST_ARCHIVE_DECL (line 95) | BOOST_ARCHIVE_DECL const basic_serializer *

FILE: src/basic_text_iprimitive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      class basic_text_iprimitive<std::istream> (line 26) | class basic_text_iprimitive<std::istream>

FILE: src/basic_text_oprimitive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      class basic_text_oprimitive<std::ostream> (line 26) | class basic_text_oprimitive<std::ostream>

FILE: src/basic_text_wiprimitive.cpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class basic_text_iprimitive<std::wistream> (line 31) | class basic_text_iprimitive<std::wistream>

FILE: src/basic_text_woprimitive.cpp
  type boost (line 28) | namespace boost {
    type archive (line 29) | namespace archive {
      class basic_text_oprimitive<std::wostream> (line 31) | class basic_text_oprimitive<std::wostream>

FILE: src/basic_xml_archive.cpp
  type boost (line 15) | namespace boost {
    type archive (line 16) | namespace archive {
      function BOOST_SYMBOL_VISIBLE (line 18) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 22) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 26) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 30) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 34) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 38) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 42) | BOOST_SYMBOL_VISIBLE const char *
      function BOOST_SYMBOL_VISIBLE (line 46) | BOOST_SYMBOL_VISIBLE const char *

FILE: src/binary_iarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      class detail::archive_serializer_map<binary_iarchive> (line 26) | class detail::archive_serializer_map<binary_iarchive>
      class basic_binary_iprimitive<
    binary_iarchive,
    std::istream::char_type, 
    std::istream::traits_type
> (line 27) | class basic_binary_iprimitive<
      class basic_binary_iarchive<binary_iarchive> (line 32) | class basic_binary_iarchive<binary_iarchive>
      class binary_iarchive_impl<
    binary_iarchive, 
    std::istream::char_type, 
    std::istream::traits_type
> (line 33) | class binary_iarchive_impl<

FILE: src/binary_oarchive.cpp
  type boost (line 23) | namespace boost {
    type archive (line 24) | namespace archive {
      class detail::archive_serializer_map<binary_oarchive> (line 26) | class detail::archive_serializer_map<binary_oarchive>
      class basic_binary_oprimitive<
    binary_oarchive, 
    std::ostream::char_type, 
    std::ostream::traits_type
> (line 27) | class basic_binary_oprimitive<
      class basic_binary_oarchive<binary_oarchive> (line 32) | class basic_binary_oarchive<binary_oarchive>
      class binary_oarchive_impl<
    binary_oarchive, 
    std::ostream::char_type, 
    std::ostream::traits_type
> (line 33) | class binary_oarchive_impl<

FILE: src/binary_wiarchive.cpp
  type boost (line 26) | namespace boost {
    type archive (line 27) | namespace archive {
      class detail::archive_serializer_map<binary_wiarchive> (line 30) | class detail::archive_serializer_map<binary_wiarchive>
      class basic_binary_iprimitive<
    binary_wiarchive,
    wchar_t, 
    std::char_traits<wchar_t> 
> (line 31) | class basic_binary_iprimitive<
      class basic_binary_iarchive<binary_wiarchive> (line 36) | class basic_binary_iarchive<binary_wiarchive>
      class binary_iarchive_impl<
    binary_wiarchive, 
    wchar_t, 
    std::char_traits<wchar_t> 
> (line 37) | class binary_iarchive_impl<

FILE: src/binary_woarchive.cpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      class detail::archive_serializer_map<binary_woarchive> (line 28) | class detail::archive_serializer_map<binary_woarchive>
      class basic_binary_oprimitive<
    binary_woarchive, 
    wchar_t, 
    std::char_traits<wchar_t> 
> (line 29) | class basic_binary_oprimitive<
      class basic_binary_oarchive<binary_woarchive> (line 34) | class basic_binary_oarchive<binary_woarchive>
      class binary_oarchive_impl<
    binary_woarchive, 
    wchar_t, 
    std::char_traits<wchar_t> 
> (line 35) | class binary_oarchive_impl<

FILE: src/codecvt_null.cpp
  type boost (line 18) | namespace boost {
    type archive (line 19) | namespace archive {
      function BOOST_SYMBOL_EXPORT (line 21) | BOOST_SYMBOL_EXPORT std::codecvt_base::result
      function BOOST_SYMBOL_EXPORT (line 49) | BOOST_SYMBOL_EXPORT std::codecvt_base::result
      function BOOST_SYMBOL_EXPORT (line 83) | BOOST_SYMBOL_EXPORT codecvt_null<wchar_t>::codecvt_null(std::size_t ...
      function BOOST_SYMBOL_EXPORT (line 87) | BOOST_SYMBOL_EXPORT codecvt_null<wchar_t>::~codecvt_null()

FILE: src/extended_type_info.cpp
  type std (line 23) | namespace std{ using ::strcmp; }
  type boost (line 44) | namespace boost {
    type serialization (line 45) | namespace serialization {
      type detail (line 46) | namespace detail {
        type key_compare (line 48) | struct key_compare
        class extended_type_info_arg (line 80) | class extended_type_info_arg : public extended_type_info
          method is_less_than (line 82) | bool
          method is_equal (line 87) | bool
          method destroy (line 99) | void destroy(void const * const /*p*/) const BOOST_OVERRIDE {
          method extended_type_info_arg (line 103) | extended_type_info_arg(const char * key) :
      function BOOST_SERIALIZATION_DECL (line 116) | BOOST_SERIALIZATION_DECL void
      function BOOST_SERIALIZATION_DECL (line 123) | BOOST_SERIALIZATION_DECL void
      function BOOST_SERIALIZATION_DECL (line 145) | BOOST_SERIALIZATION_DECL const extended_type_info *
      function BOOST_SERIALIZATION_DECL (line 166) | BOOST_SERIALIZATION_DECL
      function BOOST_SERIALIZATION_DECL (line 170) | BOOST_SERIALIZATION_DECL bool
      function BOOST_SERIALIZATION_DECL (line 183) | BOOST_SERIALIZATION_DECL bool

FILE: src/extended_type_info_no_rtti.cpp
  type std (line 18) | namespace std{ using ::strcmp; }
  type boost (line 30) | namespace boost {
    type serialization (line 31) | namespace serialization {
      type no_rtti_system (line 32) | namespace no_rtti_system {
        function BOOST_SERIALIZATION_DECL (line 34) | BOOST_SERIALIZATION_DECL
        function BOOST_SERIALIZATION_DECL (line 41) | BOOST_SERIALIZATION_DECL bool
        function BOOST_SERIALIZATION_DECL (line 64) | BOOST_SERIALIZATION_DECL bool
        function BOOST_SERIALIZATION_DECL (line 83) | BOOST_SERIALIZATION_DECL

FILE: src/extended_type_info_typeid.cpp
  type boost (line 28) | namespace boost {
    type serialization (line 29) | namespace serialization {
      type typeid_system (line 30) | namespace typeid_system {
        type type_compare (line 34) | struct type_compare
        function BOOST_SERIALIZATION_DECL (line 50) | BOOST_SERIALIZATION_DECL bool
        function BOOST_SERIALIZATION_DECL (line 62) | BOOST_SERIALIZATION_DECL bool
        function BOOST_SERIALIZATION_DECL (line 84) | BOOST_SERIALIZATION_DECL
        function BOOST_SERIALIZATION_DECL (line 88) | BOOST_SERIALIZATION_DECL void
        function BOOST_SERIALIZATION_DECL (line 94) | BOOST_SERIALIZATION_DECL void
        class extended_type_info_typeid_arg (line 125) | class extended_type_info_typeid_arg :
          method destroy (line 132) | void destroy(void const * const /*p*/) const BOOST_OVERRIDE {
          method extended_type_info_typeid_arg (line 136) | extended_type_info_typeid_arg(const std::type_info & ti) :
        function BOOST_SERIALIZATION_DECL (line 153) | BOOST_SERIALIZATION_DECL const extended_type_info *

FILE: src/polymorphic_binary_iarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class archive_serializer_map<polymorphic_binary_iarchive> (line 26) | class archive_serializer_map<polymorphic_binary_iarchive>

FILE: src/polymorphic_binary_oarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class detail::archive_serializer_map<polymorphic_binary_oarchive> (line 26) | class detail::archive_serializer_map<polymorphic_binary_oarchive>

FILE: src/polymorphic_iarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class archive_serializer_map<polymorphic_iarchive> (line 26) | class archive_serializer_map<polymorphic_iarchive>

FILE: src/polymorphic_oarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class archive_serializer_map<polymorphic_oarchive> (line 26) | class archive_serializer_map<polymorphic_oarchive>

FILE: src/polymorphic_text_iarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class archive_serializer_map<polymorphic_text_iarchive> (line 26) | class archive_serializer_map<polymorphic_text_iarchive>

FILE: src/polymorphic_text_oarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class detail::archive_serializer_map<polymorphic_text_oarchive> (line 26) | class detail::archive_serializer_map<polymorphic_text_oarchive>

FILE: src/polymorphic_text_wiarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class archive_serializer_map<polymorphic_text_wiarchive> (line 26) | class archive_serializer_map<polymorphic_text_wiarchive>

FILE: src/polymorphic_text_woarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class detail::archive_serializer_map<polymorphic_text_woarchive> (line 26) | class detail::archive_serializer_map<polymorphic_text_woarchive>

FILE: src/polymorphic_xml_iarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class archive_serializer_map<polymorphic_xml_iarchive> (line 26) | class archive_serializer_map<polymorphic_xml_iarchive>

FILE: src/polymorphic_xml_oarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class detail::archive_serializer_map<polymorphic_xml_oarchive> (line 26) | class detail::archive_serializer_map<polymorphic_xml_oarchive>

FILE: src/polymorphic_xml_wiarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class archive_serializer_map<polymorphic_xml_wiarchive> (line 26) | class archive_serializer_map<polymorphic_xml_wiarchive>

FILE: src/polymorphic_xml_woarchive.cpp
  type boost (line 22) | namespace boost {
    type archive (line 23) | namespace archive {
      type detail (line 24) | namespace detail {
        class detail::archive_serializer_map<polymorphic_xml_woarchive> (line 26) | class detail::archive_serializer_map<polymorphic_xml_woarchive>

FILE: src/stl_port.cpp
  type std (line 26) | namespace std {

FILE: src/text_iarchive.cpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      class detail::archive_serializer_map<text_iarchive> (line 28) | class detail::archive_serializer_map<text_iarchive>
      class basic_text_iarchive<text_iarchive> (line 29) | class basic_text_iarchive<text_iarchive>
      class text_iarchive_impl<text_iarchive> (line 30) | class text_iarchive_impl<text_iarchive>

FILE: src/text_oarchive.cpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      class detail::archive_serializer_map<text_oarchive> (line 29) | class detail::archive_serializer_map<text_oarchive>
      class basic_text_oarchive<text_oarchive> (line 30) | class basic_text_oarchive<text_oarchive>
      class text_oarchive_impl<text_oarchive> (line 31) | class text_oarchive_impl<text_oarchive>

FILE: src/text_wiarchive.cpp
  type boost (line 27) | namespace boost {
    type archive (line 28) | namespace archive {
      class detail::archive_serializer_map<text_wiarchive> (line 30) | class detail::archive_serializer_map<text_wiarchive>
      class basic_text_iarchive<text_wiarchive> (line 31) | class basic_text_iarchive<text_wiarchive>
      class text_wiarchive_impl<text_wiarchive> (line 32) | class text_wiarchive_impl<text_wiarchive>

FILE: src/text_woarchive.cpp
  type boost (line 26) | namespace boost {
    type archive (line 27) | namespace archive {
      class detail::archive_serializer_map<text_woarchive> (line 29) | class detail::archive_serializer_map<text_woarchive>
      class basic_text_oarchive<text_woarchive> (line 30) | class basic_text_oarchive<text_woarchive>
      class text_woarchive_impl<text_woarchive> (line 31) | class text_woarchive_impl<text_woarchive>

FILE: src/void_cast.cpp
  type boost (line 38) | namespace boost {
    type serialization (line 39) | namespace serialization {
      type void_cast_detail (line 40) | namespace void_cast_detail {
        type void_caster_compare (line 63) | struct void_caster_compare {
        class void_caster_shortcut (line 78) | class void_caster_shortcut : public void_caster
          method is_shortcut (line 102) | virtual bool is_shortcut() const {
          method has_virtual_base (line 105) | bool has_virtual_base() const BOOST_OVERRIDE {
          method void_caster_shortcut (line 109) | void_caster_shortcut(
        class void_caster_argument (line 188) | class void_caster_argument : public void_caster
          method has_virtual_base (line 200) | bool has_virtual_base() const BOOST_OVERRIDE {
          method void_caster_argument (line 205) | void_caster_argument(
        function BOOST_SERIALIZATION_DECL (line 219) | BOOST_SERIALIZATION_DECL void
        function BOOST_SERIALIZATION_DECL (line 277) | BOOST_SERIALIZATION_DECL void
      function BOOST_SERIALIZATION_DECL (line 328) | BOOST_SERIALIZATION_DECL void const *
      function BOOST_SERIALIZATION_DECL (line 358) | BOOST_SERIALIZATION_DECL void const *

FILE: src/xml_archive_exception.cpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      function BOOST_ARCHIVE_DECL (line 28) | BOOST_ARCHIVE_DECL
      function BOOST_ARCHIVE_DECL (line 59) | BOOST_ARCHIVE_DECL
      function BOOST_ARCHIVE_DECL (line 65) | BOOST_ARCHIVE_DECL xml_archive_exception::~xml_archive_exception() B...

FILE: src/xml_grammar.cpp
  type std (line 28) | namespace std {
    function string (line 30) | inline string &
  type boost (line 43) | namespace boost {
    type archive (line 44) | namespace archive {
      class basic_xml_grammar<char> (line 70) | class basic_xml_grammar<char>
    type archive (line 67) | namespace archive {
      class basic_xml_grammar<char> (line 70) | class basic_xml_grammar<char>
  type boost (line 66) | namespace boost {
    type archive (line 44) | namespace archive {
      class basic_xml_grammar<char> (line 70) | class basic_xml_grammar<char>
    type archive (line 67) | namespace archive {
      class basic_xml_grammar<char> (line 70) | class basic_xml_grammar<char>

FILE: src/xml_iarchive.cpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      class detail::archive_serializer_map<xml_iarchive> (line 28) | class detail::archive_serializer_map<xml_iarchive>
      class basic_xml_iarchive<xml_iarchive> (line 29) | class basic_xml_iarchive<xml_iarchive>
      class xml_iarchive_impl<xml_iarchive> (line 30) | class xml_iarchive_impl<xml_iarchive>

FILE: src/xml_oarchive.cpp
  type boost (line 25) | namespace boost {
    type archive (line 26) | namespace archive {
      class detail::archive_serializer_map<xml_oarchive> (line 28) | class detail::archive_serializer_map<xml_oarchive>
      class basic_xml_oarchive<xml_oarchive> (line 29) | class basic_xml_oarchive<xml_oarchive>
      class xml_oarchive_impl<xml_oarchive> (line 30) | class xml_oarchive_impl<xml_oarchive>

FILE: src/xml_wgrammar.cpp
  type std (line 27) | namespace std {
    function wstring (line 29) | inline wstring &
  type boost (line 42) | namespace boost {
    type archive (line 43) | namespace archive {
      class basic_xml_grammar<wchar_t> (line 152) | class basic_xml_grammar<wchar_t>
    type archive (line 149) | namespace archive {
      class basic_xml_grammar<wchar_t> (line 152) | class basic_xml_grammar<wchar_t>
  type boost (line 148) | namespace boost {
    type archive (line 43) | namespace archive {
      class basic_xml_grammar<wchar_t> (line 152) | class basic_xml_grammar<wchar_t>
    type archive (line 149) | namespace archive {
      class basic_xml_grammar<wchar_t> (line 152) | class basic_xml_grammar<wchar_t>

FILE: src/xml_wiarchive.cpp
  type boost (line 30) | namespace boost {
    type archive (line 31) | namespace archive {
      class detail::archive_serializer_map<xml_wiarchive> (line 33) | class detail::archive_serializer_map<xml_wiarchive>
      class basic_xml_iarchive<xml_wiarchive> (line 34) | class basic_xml_iarchive<xml_wiarchive>
      class xml_wiarchive_impl<xml_wiarchive> (line 35) | class xml_wiarchive_impl<xml_wiarchive>

FILE: src/xml_woarchive.cpp
  type boost (line 30) | namespace boost {
    type archive (line 31) | namespace archive {
      class detail::archive_serializer_map<xml_woarchive> (line 33) | class detail::archive_serializer_map<xml_woarchive>
      class basic_xml_oarchive<xml_woarchive> (line 34) | class basic_xml_oarchive<xml_woarchive>
      class xml_woarchive_impl<xml_woarchive> (line 35) | class xml_woarchive_impl<xml_woarchive>

FILE: test/A.cpp
  type std (line 21) | namespace std{
  function randomize (line 35) | void randomize(S &x)
  function accumulate (line 47) | void accumulate(std::size_t & s, const T & t){
  function A_DLL_DECL (line 54) | A_DLL_DECL
  type h (line 91) | enum h
  function A_DLL_DECL (line 118) | A_DLL_DECL bool
  function A_DLL_DECL (line 170) | A_DLL_DECL bool
  function A_DLL_DECL (line 175) | A_DLL_DECL bool

FILE: test/A.hpp
  type std (line 24) | namespace std{
  function A (line 47) | class A_DLL_DECL A {

FILE: test/B.hpp
  type std (line 24) | namespace std{
  class B (line 37) | class B : public A
    method save (line 42) | void save(Archive &ar, const unsigned int /* file_version */) const
    method load (line 49) | void load(Archive & ar, const unsigned int file_version)

FILE: test/C.hpp
  class C (line 27) | class C
  function save (line 49) | inline void save(Archive &ar, boost::archive::version_type file_version)...

FILE: test/D.hpp
  class D (line 30) | class D
    method save (line 37) | void save(Archive &ar, const unsigned int file_version) const{
    method load (line 43) | void load(Archive & ar, const unsigned int file_version){
    method BOOST_CATCH (line 48) | BOOST_CATCH (...){

FILE: test/J.hpp
  class J (line 25) | class J : public A
    method serialize (line 30) | void serialize(
    method J (line 40) | J(J *_j) : j(_j) {}
    method J (line 41) | J() : j(NULL){}

FILE: test/base.hpp
  function base (line 33) | class DLL_DECL base

FILE: test/derived2.hpp
  function derived2 (line 35) | class DLL_DECL derived2 :

FILE: test/multi_shared1.cpp
  type X1 (line 13) | struct X1{
    method serialize (line 15) | void serialize(Archive &, const unsigned int){}
  function f (line 20) | bool f(){

FILE: test/multi_shared2.cpp
  type X2 (line 12) | struct X2{
    method serialize (line 14) | void serialize(Archive &, const unsigned int){}
  function g (line 19) | bool g(){

FILE: test/polymorphic_base.cpp
  function POLYMORPHIC_BASE_DLL_DECL (line 16) | POLYMORPHIC_BASE_DLL_DECL void polymorphic_base::serialize(
  function POLYMORPHIC_BASE_DLL_DECL (line 21) | POLYMORPHIC_BASE_DLL_DECL
  function POLYMORPHIC_BASE_DLL_DECL (line 23) | POLYMORPHIC_BASE_DLL_DECL

FILE: test/polymorphic_base.hpp
  function polymorphic_base (line 39) | class BOOST_SYMBOL_VISIBLE polymorphic_base

FILE: test/polymorphic_derived1.hpp
  class polymorphic_derived1 (line 27) | class polymorphic_derived1 : public polymorphic_base
    method serialize (line 31) | void serialize(Archive &ar, const unsigned int  /* file_version */){

FILE: test/polymorphic_derived2.cpp
  function POLYMORPHIC_DERIVED2_DLL_DECL (line 19) | POLYMORPHIC_DERIVED2_DLL_DECL void polymorphic_derived2::serialize(
  function POLYMORPHIC_DERIVED2_DLL_DECL (line 29) | POLYMORPHIC_DERIVED2_DLL_DECL
  function POLYMORPHIC_DERIVED2_DLL_DECL (line 31) | POLYMORPHIC_DERIVED2_DLL_DECL

FILE: test/polymorphic_derived2.hpp
  function polymorphic_derived2 (line 42) | class BOOST_SYMBOL_VISIBLE polymorphic_derived2 :

FILE: test/test__helper.cpp
  type std (line 17) | namespace std{
  class my_string (line 44) | class my_string:public std::string
    method my_string (line 49) | my_string(){}
    method my_string (line 50) | my_string(const super & str): super(str){}
    method my_string (line 51) | my_string & operator=(const super& rhs) {
  type my_string_helper (line 57) | struct my_string_helper
  type boost (line 65) | namespace boost {
    type serialization (line 66) | namespace serialization {
      function save (line 69) | void save(Archive & ar, const my_string & str, const unsigned int /*...
      function load (line 90) | void load(Archive & ar, my_string & str, const unsigned int /* versi...
  function test_main (line 117) | int test_main(int /* argc */, char * /* argv */ [])

FILE: test/test_array.cpp
  type std (line 19) | namespace std{
  function test_std_array (line 32) | int test_std_array(){
  function test_main (line 77) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_binary.cpp
  type std (line 18) | namespace std{
  class A (line 29) | class A {
    method serialize (line 36) | void serialize(Archive & ar, const unsigned int /* file_version */){
  function test_main (line 62) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_bitset.cpp
  type std (line 19) | namespace std
  function test_main (line 30) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_boost_array.cpp
  type std (line 19) | namespace std{
  function test_boost_array (line 32) | int test_boost_array(){
  function test_main (line 78) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_check.cpp
  type check1 (line 23) | struct check1 {
    method check1 (line 26) | check1(){}
  type check2 (line 34) | struct check2 {
    method check2 (line 37) | check2(){}
  type check3 (line 47) | struct check3 {
    method check3 (line 50) | check3(){}
  function f (line 56) | int f(){
  function main (line 64) | int main(int /* argc */, char * /* argv */[]){

FILE: test/test_class_info_load.cpp
  class A (line 24) | class A
    method serialize (line 28) | void serialize(Archive & /*ar*/, const unsigned int file_version){
    method A (line 36) | A() : count(0) {}
  class B (line 43) | class B
    method serialize (line 47) | void serialize(Archive & /*ar*/, const unsigned int file_version){
    method B (line 55) | B() : count(0) {}
  function in (line 62) | void in(const char *testfile, A & a, B & b)
  function test_main (line 77) | int

FILE: test/test_class_info_save.cpp
  class A (line 25) | class A
    method serialize (line 29) | void serialize(Archive & /*ar*/, const unsigned int file_version){
    method A (line 37) | A() : count(0) {}
  class B (line 45) | class B
    method serialize (line 52) | void serialize(Archive & /*ar*/, const unsigned int file_version){
    method B (line 62) | B() : count(0) {}
  class B (line 48) | class B
    method serialize (line 52) | void serialize(Archive & /*ar*/, const unsigned int file_version){
    method B (line 62) | B() : count(0) {}
  function out (line 70) | void out(const char *testfile, const A & a, const B & b)
  function test_main (line 85) | int

FILE: test/test_codecvt_null.cpp
  type std (line 24) | namespace std{
  type test_data (line 36) | struct test_data
  function test_main (line 70) | int test_main( int /* argc */, char* /* argv */[] ) {

FILE: test/test_complex.cpp
  type std (line 24) | namespace std{
  function test_main (line 42) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_const_load_fail1.cpp
  type A (line 15) | struct A {
    method serialize (line 17) | void serialize(Archive & ar, unsigned int version) {
  function f1 (line 21) | void f1(text_iarchive & ia, const A & a){

FILE: test/test_const_load_fail1_nvp.cpp
  type A (line 16) | struct A {
    method serialize (line 18) | void serialize(Archive & ar, unsigned int version) {
  function f1 (line 22) | void f1(text_iarchive & ia, const A & a){

FILE: test/test_const_load_fail2.cpp
  type A (line 15) | struct A {
    method serialize (line 17) | void serialize(Archive & ar, unsigned int version) {
  function f2 (line 21) | void f2(text_iarchive & ia, A * const & a){

FILE: test/test_const_load_fail2_nvp.cpp
  type A (line 16) | struct A {
    method serialize (line 18) | void serialize(Archive & ar, unsigned int version) {
  function f2 (line 22) | void f2(text_iarchive & ia, A * const & a){

FILE: test/test_const_load_fail3.cpp
  type A (line 14) | struct A {
    method serialize (line 16) | void serialize(Archive & ar, unsigned int version) {
  function f2 (line 20) | void f2(text_iarchive & ia, const A * const & a){

FILE: test/test_const_load_fail3_nvp.cpp
  type A (line 16) | struct A {
    method serialize (line 18) | void serialize(Archive & ar, unsigned int version) {
  function f2 (line 22) | void f2(text_iarchive & ia, const A * const & a){

FILE: test/test_const_pass.cpp
  type A (line 15) | struct A {
    method serialize (line 17) | void serialize(Archive & ar, unsigned int version) {
  function f1 (line 22) | void f1(boost::archive::text_oarchive & oa, const A & a){
  function f2 (line 28) | void f2(boost::archive::text_oarchive & oa, const A * const & a){
  function f3 (line 34) | void f3(boost::archive::text_iarchive & ia, A & a){
  function f4 (line 40) | void f4(boost::archive::text_iarchive & ia, A * & a){
  function f5 (line 47) | void f5(boost::archive::text_oarchive & oa, const A * & a){

FILE: test/test_const_save_warn1.cpp
  type A (line 15) | struct A {
    method serialize (line 17) | void serialize(Archive & ar, unsigned int version) {
  function f1 (line 22) | void f1(text_oarchive & oa, A  & a){

FILE: test/test_const_save_warn1_nvp.cpp
  type A (line 17) | struct A {
    method serialize (line 19) | void serialize(Archive & ar, unsigned int version) {
  function f1 (line 23) | void f1(text_oarchive & oa, A & a){

FILE: test/test_const_save_warn2.cpp
  type A (line 15) | struct A {
    method serialize (line 17) | void serialize(Archive & ar, unsigned int version) {
  function f2 (line 21) | void f2(text_oarchive & oa, A * & a){

FILE: test/test_const_save_warn2_nvp.cpp
  type A (line 16) | struct A {
    method serialize (line 18) | void serialize(Archive & ar, unsigned int version) {
  function f2 (line 22) | void f2(text_oarchive & oa, A * & a){

FILE: test/test_const_save_warn3.cpp
  type A (line 15) | struct A {
    method serialize (line 17) | void serialize(Archive & ar, unsigned int version) {
  function f3 (line 21) | void f3(text_oarchive & oa, const A * & a){

FILE: test/test_const_save_warn3_nvp.cpp
  type A (line 16) | struct A {
    method serialize (line 18) | void serialize(Archive & ar, unsigned int version) {
  function f3 (line 22) | void f3(text_oarchive & oa, const A * & a){

FILE: test/test_const_save_warn4.cpp
  type A (line 16) | struct A {
    method serialize (line 18) | void serialize(Archive & ar, unsigned int version) {
  function f4 (line 34) | void f4(text_oarchive & oa, A * const & a){

FILE: test/test_const_save_warn4_nvp.cpp
  type A (line 16) | struct A {
    method serialize (line 18) | void serialize(Archive & ar, unsigned int version) {
  function f4 (line 37) | void f4(text_oarchive & oa, A * const & a){

FILE: test/test_contained_class.cpp
  type std (line 17) | namespace std{
  class C (line 30) | class C
    method serialize (line 35) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method C (line 44) | C(){}
  function test_main (line 47) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_cyclic_ptrs.cpp
  type std (line 17) | namespace std{
  class J (line 33) | class J : public A
    method serialize (line 38) | void serialize(Archive &ar, const unsigned int /* file_version */){
    method J (line 45) | J(J *_j) : j(_j) {}
    method J (line 46) | J() : j(NULL){}
  class K (line 68) | class K
    method serialize (line 75) | void serialize(
  function test1 (line 105) | int test1(){
  function test2 (line 126) | int test2(){
  function test3 (line 151) | int test3(){
  function BOOST_CATCH (line 184) | BOOST_CATCH (boost::archive::archive_exception const& ae){
  function test_main (line 196) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_delete_pointer.cpp
  type std (line 16) | namespace std{
  class A (line 30) | class A
    method save (line 34) | void save(Archive &ar, const unsigned int /* file_version */) const
    method load (line 39) | void load(Archive & ar, const unsigned int /* file_version */)
    method BOOST_SERIALIZATION_SPLIT_MEMBER (line 44) | BOOST_SERIALIZATION_SPLIT_MEMBER()
  function test_main (line 70) | int

FILE: test/test_deque.cpp
  type std (line 17) | namespace std{
  function test_main (line 30) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_derived.cpp
  type std (line 17) | namespace std{
  class base (line 28) | class base
    method serialize (line 32) | void serialize(Archive & /* ar */, const unsigned int /* file_version ...
  class derived1 (line 38) | class derived1 : public base
    method serialize (line 42) | void serialize(Archive &ar, const unsigned int /* file_version */){
  class derived2 (line 47) | class derived2 : public base
    method serialize (line 51) | void serialize(Archive &ar, const unsigned int /* file_version */){
  function save_derived (line 57) | void save_derived(const char *testfile)
  function load_derived (line 95) | void load_derived(const char *testfile)
  function test_main (line 136) | int

FILE: test/test_derived_class.cpp
  type std (line 16) | namespace std{
  function test_main (line 26) | int test_main( int /*argc*/, char* /*argv*/[] )

FILE: test/test_derived_class_ptr.cpp
  type std (line 17) | namespace std{
  function test_main (line 27) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_diamond.cpp
  type std (line 18) | namespace std{
  class base (line 36) | class base {
    method base (line 38) | base() : i(0) {}
    method base (line 39) | base(int i) : i(i)
    method save (line 45) | void save(Archive &ar, const unsigned int /* file_version */) const
    method load (line 54) | void load(Archive & ar, const unsigned int /* file_version */)
  function save (line 92) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 99) | void load(Archive & ar, const unsigned int /* file_version */)
  function save (line 111) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 118) | void load(Archive & ar, const unsigned int /* file_version */)
  function final (line 129) | final() {}
  function final (line 130) | final(int i) : base(i) {}
  function save (line 133) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 141) | void load(Archive & ar, const unsigned int /* file_version */)
  function test_main (line 153) | int

FILE: test/test_diamond_complex.cpp
  type std (line 18) | namespace std{
  class EX1Level1 (line 50) | class EX1Level1 {
    method EX1Level1 (line 52) | EX1Level1() : i(0) {}
    method EX1Level1 (line 53) | EX1Level1(int i) : i(i)
    method save (line 59) | void save(Archive &ar, const unsigned int /* file_version */) const
    method load (line 68) | void load(Archive & ar, const unsigned int /* file_version */)
  function save (line 106) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 113) | void load(Archive & ar, const unsigned int /* file_version */)
  function save (line 125) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 132) | void load(Archive & ar, const unsigned int /* file_version */)
  function EX1Level3_A (line 143) | EX1Level3_A() {}
  function EX1Level3_A (line 144) | EX1Level3_A(int i) : EX1Level1(i) {}
  function save (line 147) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 155) | void load(Archive & ar, const unsigned int /* file_version */)
  function EX1Level3_B (line 168) | EX1Level3_B() {}
  function EX1Level3_B (line 169) | EX1Level3_B(int) {}
  function save (line 172) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 180) | void load(Archive & ar, const unsigned int /* file_version */)
  function EX1Level4 (line 192) | EX1Level4() {}
  function EX1Level4 (line 193) | EX1Level4(int i) : EX1Level1(i) {}
  function save (line 196) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 203) | void load(Archive & ar, const unsigned int /* file_version */)
  class EX2Level1 (line 213) | class EX2Level1 {
    method EX2Level1 (line 215) | EX2Level1() : i(0) {}
    method EX2Level1 (line 216) | EX2Level1(int i) : i(i)
    method save (line 222) | void save(Archive &ar, const unsigned int /* file_version */) const
    method load (line 231) | void load(Archive & ar, const unsigned int /* file_version */)
  function save (line 269) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 276) | void load(Archive & ar, const unsigned int /* file_version */)
  function save (line 288) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 295) | void load(Archive & ar, const unsigned int /* file_version */)
  function EX2Level3_A (line 306) | EX2Level3_A() {}
  function EX2Level3_A (line 307) | EX2Level3_A(int i) : EX2Level1(i) {}
  function save (line 310) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 318) | void load(Archive & ar, const unsigned int /* file_version */)
  function EX2Level3_B (line 331) | EX2Level3_B() {}
  function EX2Level3_B (line 332) | EX2Level3_B(int i) : EX2Level1(i) {}
  function save (line 335) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 343) | void load(Archive & ar, const unsigned int /* file_version */)
  function EX2Level4 (line 355) | EX2Level4() {}
  function EX2Level4 (line 356) | EX2Level4(int i) : EX2Level1(i) {}
  function save (line 359) | void save(Archive &ar, const unsigned int /* file_version */) const
  function load (line 366) | void load(Archive & ar, const unsigned int /* file_version */)
  function test_main (line 381) | int

FILE: test/test_dll_exported.cpp
  type std (line 33) | namespace std{
  function save_exported (line 59) | void save_exported(const char *testfile)
  function load_exported (line 81) | void load_exported(const char *testfile)
  function test_main (line 125) | int

FILE: test/test_dll_plugin.cpp
  type std (line 24) | namespace std{
  class polymorphic_derived1 (line 44) | class polymorphic_derived1 : public polymorphic_base
    method serialize (line 48) | void serialize(Archive &ar, const unsigned int /* file_version */){
  function save_exported (line 70) | void save_exported(const char *testfile)
  function load_exported (line 114) | void load_exported(const char *testfile)
  function test_main (line 161) | int
  function test_main (line 188) | int

FILE: test/test_dll_simple.cpp
  type std (line 20) | namespace std{
  function test1 (line 36) | void
  function test2 (line 59) | void
  function test3 (line 84) | void
  function test4 (line 108) | void
  function test5 (line 136) | void
  function test6 (line 159) | void
  function test7 (line 184) | void
  function test8 (line 208) | void
  function test_main (line 234) | int

FILE: test/test_enable_shared_from_this.cpp
  type boost (line 42) | namespace boost {
    type serialization (line 43) | namespace serialization {
      type enable_shared_from_this_helper (line 45) | struct enable_shared_from_this_helper {
        method record (line 47) | void record(boost::shared_ptr<void>  sp){
      function serialize (line 53) | void serialize(
  class Base (line 70) | class Base {
    method serialize (line 74) | void serialize(Archive & ar, const unsigned int version)
    method Base (line 79) | Base() {}
  class Derived (line 85) | class Derived : public Base, public boost::enable_shared_from_this<Deriv...
    method serialize (line 89) | void serialize(Archive & ar, const unsigned int version)
    method SharedPtr (line 98) | boost::shared_ptr<Derived> SharedPtr() { return shared_from_this(); }
    method Derived (line 100) | Derived() {}
  function test_passes (line 107) | void test_passes(){
  function test_fails (line 147) | void test_fails(){
  function test_main (line 189) | int test_main(int /*argc*/, char * /*argv */[]){

FILE: test/test_exported.cpp
  type std (line 17) | namespace std{
  function save_exported (line 35) | void save_exported(const char *testfile)
  function load_exported (line 57) | void load_exported(const char *testfile)
  function test_main (line 92) | int

FILE: test/test_forward_list.cpp
  type std (line 15) | namespace std{
  function test_main (line 29) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_forward_list_ptrs.cpp
  type std (line 17) | namespace std{
  type ptr_equal_to (line 35) | struct ptr_equal_to {
  function test_forward_list (line 48) | void test_forward_list(){
  function test_main (line 87) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_helper_support.cpp
  type std (line 18) | namespace std{
  class my_string (line 33) | class my_string:public std::string
    method my_string (line 38) | my_string(){}
    method my_string (line 39) | my_string(const super & str): super(str){}
    method my_string (line 40) | my_string & operator=(const super& rhs) {
  type my_string_helper (line 46) | struct my_string_helper
  type boost (line 54) | namespace boost {
    type serialization (line 55) | namespace serialization {
      function save (line 58) | void save(Archive & ar, const my_string & str, const unsigned int /*...
      function load (line 79) | void load(Archive & ar, my_string & str, const unsigned int /* versi...
  function test_main (line 104) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_inclusion.cpp
  type foo (line 23) | struct foo
    method serialize (line 30) | void serialize(Archive & ar, const unsigned int version)
  function main (line 39) | int

FILE: test/test_inclusion2.cpp
  function f (line 14) | void f()
  function main (line 22) | int

FILE: test/test_interrupts.cpp
  type std (line 19) | namespace std{
  type test_dummy_out (line 30) | struct test_dummy_out {
    method save (line 32) | void save(Archive &, const unsigned int /*version*/) const {
    method load (line 38) | void load(Archive & ar, const unsigned int version){
    method test_dummy_out (line 41) | test_dummy_out(){}
  function test_out (line 45) | int test_out(){
  type test_dummy_in (line 78) | struct test_dummy_in {
    method save (line 80) | void save(Archive & /* ar */, const unsigned int /*version*/) const {
    method load (line 83) | void load(Archive & /* ar */, const unsigned int /*version*/){
    method test_dummy_in (line 89) | test_dummy_in(){}
  function test_in (line 93) | int test_in(){
  function test_main (line 135) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_iterators.cpp
  type std (line 19) | namespace std{
  function test_wchar_from_mb (line 43) | void test_wchar_from_mb(const wchar_t *la, const char * a, const unsigne...
  function test_mb_from_wchar (line 54) | void test_mb_from_wchar(const char * a, const wchar_t *la, const unsigne...
  function test_roundtrip (line 65) | void test_roundtrip(const wchar_t * la){
  function test_xml_escape (line 94) | void test_xml_escape(
  function test_xml_unescape (line 111) | void test_xml_unescape(
  function test_transform_width (line 130) | void test_transform_width(unsigned int size){
  function test_stream_iterators (line 181) | void test_stream_iterators(
  function test_main (line 198) | int

FILE: test/test_iterators_base64.cpp
  type std (line 21) | namespace std{
  function test_base64 (line 38) | void test_base64(unsigned int size){
  function test_main (line 89) | int

FILE: test/test_list.cpp
  type std (line 17) | namespace std{
  function test_list (line 29) | void test_list(){
  function test_main (line 52) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_list_ptrs.cpp
  type std (line 17) | namespace std{
  type ptr_equal_to (line 35) | struct ptr_equal_to {
  function test_list (line 48) | void test_list(){
  function test_main (line 92) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_map.cpp
  type std (line 22) | namespace std{
  type random_key (line 39) | struct random_key {
    method serialize (line 42) | void serialize(
    method random_key (line 49) | random_key() : m_i(std::rand()){}
  function test_map (line 61) | void
  function test_map_2 (line 86) | void
  function test_multimap (line 118) | void
  function test_main (line 142) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_map_hashed.cpp
  type std (line 23) | namespace std{
  type random_key (line 47) | struct random_key {
    method serialize (line 50) | void serialize(
    method random_key (line 57) | random_key() : m_i(std::rand()){}
  type BOOST_STD_EXTENSION_NAMESPACE (line 69) | namespace BOOST_STD_EXTENSION_NAMESPACE {
    type hash<random_key> (line 71) | struct hash<random_key>{
  function test_hash_map (line 78) | void
  function test_hash_multimap (line 110) | void
  function test_main (line 140) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_mi.cpp
  type std (line 19) | namespace std{
  class A (line 29) | class A
    method serialize (line 35) | void serialize(Archive &ar, const unsigned int /* file_version */){
    method A (line 39) | explicit A(int x = 0): x(x) {}
    method get_x (line 41) | int get_x() const
  class B (line 51) | class B
    method serialize (line 57) | void serialize(Archive &ar, const unsigned int /* file_version */){
    method B (line 61) | explicit B(int y = 0): y(y) {}
    method get_y (line 63) | int get_y() const
  class C (line 69) | class C: public A, public B
    method serialize (line 74) | void serialize(Archive &ar, const unsigned int /* file_version */){
    method C (line 79) | C(){}
    method C (line 80) | C(int x, int y): A(x), B(y){}
  function test_main (line 83) | int

FILE: test/test_mult_archive_types.cpp
  type std (line 15) | namespace std{
  class A (line 31) | class A
    method serialize (line 37) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method A (line 42) | A(){++count;}
  class B (line 49) | class B : public A
    method serialize (line 54) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method B (line 59) | B() : A() {}
  function test_save_and_load (line 71) | void test_save_and_load(A * first, A * second)
  function test_main (line 102) | int test_main(int /* argc */, char * /* argv */[])

FILE: test/test_multi_shared_lib.cpp
  function main (line 26) | int main(int argc, char**){

FILE: test/test_multiple_inheritance.cpp
  type std (line 17) | namespace std{
  type Base1 (line 29) | struct Base1 {
    method Base1 (line 31) | Base1(){}
    method Base1 (line 32) | Base1(int x) : m_x(1 + x) {}
    method serialize (line 40) | void serialize(Archive & ar, const unsigned int /* file_version */) {
  type Base2 (line 47) | struct Base2 {
    method Base2 (line 49) | Base2(){}
    method Base2 (line 50) | Base2(int x) : m_x(2 + x) {}
    method serialize (line 58) | void serialize(Archive & ar, const unsigned int /* file_version */) {
  type Sub (line 65) | struct Sub :
    method Sub (line 70) | Sub(){}
    method Sub (line 71) | Sub(int x) :
    method serialize (line 88) | void serialize(Archive &ar, const unsigned int /* file_version */)
  function test_main (line 98) | int

FILE: test/test_multiple_ptrs.cpp
  type std (line 17) | namespace std{
  function test_main (line 27) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_native_array.cpp
  type std (line 19) | namespace std{
  function test_native_array (line 31) | int test_native_array(){
  function test_main (line 88) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_new_operator.cpp
  type std (line 18) | namespace std{
  class ANew (line 30) | class ANew : public A {
    method serialize (line 33) | void serialize(Archive & ar, const unsigned /*file_version*/){
  class ANew1 (line 54) | class ANew1 : public A {
    method serialize (line 57) | void serialize(Archive & ar, const unsigned /*file_version*/){
  class ANew2 (line 79) | class ANew2 : public A {
    method serialize (line 82) | void serialize(Archive & ar, const unsigned /*file_version*/){
  function test (line 100) | int test(){
  function test_main (line 139) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_no_rtti.cpp
  type std (line 24) | namespace std{
  function save_derived (line 45) | void save_derived(const char *testfile)
  function load_derived (line 71) | void load_derived(const char *testfile)
  function test_main (line 154) | int

FILE: test/test_non_default_ctor.cpp
  type std (line 26) | namespace std{
  class A (line 41) | class A
    method serialize (line 59) | void serialize(Archive & ar,const unsigned int /* file_version */){
  type boost (line 129) | namespace boost {
    type serialization (line 130) | namespace serialization {
      function save_construct_data (line 133) | inline void save_construct_data(
      function load_construct_data (line 143) | inline void load_construct_data(
  function save (line 156) | void save(const char * testfile){
  function load (line 173) | void load(const char * testfile){
  function test_main (line 191) | int

FILE: test/test_non_default_ctor2.cpp
  class IntValueHolder (line 20) | class IntValueHolder
    method IntValueHolder (line 23) | IntValueHolder()
    method IntValueHolder (line 27) | IntValueHolder(int newvalue)
    method GetValue (line 31) | int GetValue() const { return value; }
    method serialize (line 39) | void serialize(ArchiveT& ar, const unsigned int /* file_version */)
  class FloatValueHolder (line 45) | class FloatValueHolder
    method FloatValueHolder (line 48) | FloatValueHolder()
    method FloatValueHolder (line 52) | FloatValueHolder(float newvalue)
    method GetValue (line 56) | float GetValue() const { return value; }
    method serialize (line 64) | void serialize(ArchiveT& ar, const unsigned int /* file_version */)
  class A (line 70) | class A
    method A (line 73) | A(const IntValueHolder& initialValue)
    method serialize (line 89) | void serialize(ArchiveT& ar, const unsigned int /* file_version */)
  type boost (line 95) | namespace boost {
    type serialization (line 96) | namespace serialization {
      function save_construct_data (line 99) | void save_construct_data(
      function load_construct_data (line 108) | void load_construct_data(
  function test_main (line 122) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_non_intrusive.cpp
  type std (line 26) | namespace std{
  class A (line 41) | class A
  type boost (line 102) | namespace boost {
    type serialization (line 103) | namespace serialization {
      function serialize (line 117) | void serialize(
  function save (line 133) | void save(const char * testfile){
  function load (line 151) | void load(const char * testfile){
  function test_main (line 169) | int

FILE: test/test_not_serializable.cpp
  class A (line 18) | class A
  function out (line 24) | void out(A & a)
  function in (line 31) | void in(A & a)
  function test_main (line 38) | int

FILE: test/test_null_ptr.cpp
  type std (line 17) | namespace std{
  class polymorphic_base (line 25) | class polymorphic_base
    method serialize (line 29) | void serialize(Archive & /* ar */, const unsigned int /* file_version ...
  class polymorphic_derived1 (line 35) | class polymorphic_derived1 : public polymorphic_base
    method serialize (line 39) | void serialize(Archive &ar, const unsigned int /* file_version */){
  function save (line 45) | void save(const char *testfile)
  function load (line 58) | void load(const char *testfile)
  function test_main (line 78) | int

FILE: test/test_nvp.cpp
  type std (line 17) | namespace std{
  function test_main (line 29) | int

FILE: test/test_object.cpp
  type std (line 18) | namespace std{
  class A (line 28) | class A
    method serialize (line 32) | void serialize(Archive & /* ar */, const unsigned int /* file_version ...
  function out (line 43) | void out(const char *testfile, A & a)
  function in (line 50) | void in(const char *testfile, A & a)
  function test_main (line 57) | int

FILE: test/test_optional.cpp
  type std (line 18) | namespace std{
  type A (line 27) | struct A {
    method serialize (line 30) | void serialize(Archive & ar, const unsigned int /* version */){
    method A (line 37) | A() :
    method A (line 40) | A(int x) :
  function test (line 47) | int test(){
  function test_main (line 100) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_p_helper.cpp
  type std (line 17) | namespace std{
  class my_string (line 43) | class my_string:public std::string
    method my_string (line 48) | my_string(){}
    method my_string (line 49) | my_string(const super & str): super(str){}
    method my_string (line 50) | my_string & operator=(const super& rhs) {
  type my_string_helper (line 56) | struct my_string_helper
  type boost (line 64) | namespace boost {
    type serialization (line 65) | namespace serialization {
      function save (line 68) | void save(Archive & ar, const my_string & str, const unsigned int /*...
      function load (line 89) | void load(Archive & ar, my_string & str, const unsigned int /* versi...
  function test_main (line 116) | int test_main(int /* argc */, char * /* argv */ [])

FILE: test/test_pimpl.cpp
  class B (line 18) | class B
  class A (line 20) | class A {
  function test_main (line 27) | int test_main( int argc, char* argv[] )

FILE: test/test_polymorphic.cpp
  type std (line 17) | namespace std{
  function test_main (line 40) | int test_main(int /* argc */, char * /* argv */ [])

FILE: test/test_polymorphic2.cpp
  function test_main (line 16) | int test_main(int /*argc*/, char* /*argv*/[])

FILE: test/test_polymorphic2.hpp
  type boost (line 10) | namespace boost {
    type archive (line 11) | namespace archive {
      class polymorphic_oarchive (line 12) | class polymorphic_oarchive
      class polymorphic_iarchive (line 13) | class polymorphic_iarchive
  type A (line 17) | struct A {
    method A (line 19) | A() {}
  type B (line 34) | struct B : A {

FILE: test/test_polymorphic_A.hpp
  class A (line 15) | class A
  type data (line 17) | struct data {

FILE: test/test_primitive.cpp
  type A (line 21) | struct A
    method serialize (line 24) | void serialize(Archive &ar, const unsigned int /* file_version */){
  function out (line 40) | void out(const char *testfile, A & a)
  function in (line 47) | void in(const char *testfile, A & a)
  function test_main (line 54) | int

FILE: test/test_priority_queue.cpp
  type std (line 17) | namespace std{
  function test_main (line 30) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_private_base.cpp
  type std (line 16) | namespace std{
  class Base (line 27) | class Base {
    method serialize (line 31) | void serialize(Archive & ar, const unsigned int version){
    method equals (line 35) | bool equals(const Base &rhs) const {
    method Base (line 38) | Base(int i = 0) :
  class Derived (line 44) | class Derived : private Base {
    method Base (line 47) | Base & base_cast(){
    method serialize (line 51) | void serialize(Archive & ar, const unsigned int version){
    method Derived (line 58) | Derived(int i = 0) :
  function test_main (line 63) | int

FILE: test/test_private_base2.cpp
  type std (line 16) | namespace std{
  class Base (line 27) | class Base {
    method serialize (line 31) | void serialize(Archive & ar, const unsigned int version){
    method equals (line 35) | bool equals(const Base &rhs) const {
    method Base (line 38) | Base(int i = 0) :
  class Derived (line 48) | class Derived : private Base {
    method Derived (line 54) | Derived(int i = 0) :
  function test_main (line 61) | int

FILE: test/test_private_ctor.cpp
  class V (line 18) | class V {
    method V (line 23) | V() :
    method serialize (line 27) | void serialize(Archive& ar, unsigned /*version*/)
  function test_main (line 38) | int test_main(int /* argc */, char * /* argv */[])

FILE: test/test_queue.cpp
  type std (line 17) | namespace std{
  function test_main (line 31) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_recursion.cpp
  type std (line 17) | namespace std{
  function test_main (line 27) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_registered.cpp
  type std (line 17) | namespace std{
  class polymorphic_base (line 28) | class polymorphic_base
    method serialize (line 32) | void serialize(Archive & /* ar */, const unsigned int /* file_version ...
  class polymorphic_derived1 (line 38) | class polymorphic_derived1 : public polymorphic_base
    method serialize (line 42) | void serialize(Archive &ar, const unsigned int /* file_version */){
  class polymorphic_derived2 (line 47) | class polymorphic_derived2 : public polymorphic_base
    method serialize (line 51) | void serialize(Archive &ar, const unsigned int /* file_version */){
  function save_derived (line 57) | void save_derived(const char *testfile)
  function load_derived (line 85) | void load_derived(const char *testfile)
  function save_registered (line 170) | void save_registered(const char *testfile)
  function load_registered (line 189) | void load_registered(const char *testfile)
  function test_main (line 223) | int

FILE: test/test_reset_object_address.cpp
  type std (line 16) | namespace std{
  function test1 (line 40) | void test1(){
  class B (line 63) | class B {
    method serialize (line 67) | void serialize(Archive &ar, const unsigned int /*file_version*/){
    method B (line 74) | B() :
  function test2 (line 81) | void test2(){
  class D (line 110) | class D {
    method serialize (line 113) | void serialize(Archive &ar, const unsigned int /*file_version*/){
    method D (line 121) | D(){}
  function test3 (line 126) | void test3(){
  class E (line 151) | class E {
    method serialize (line 155) | void serialize(Archive &ar, const unsigned int /*file_version*/){
    method E (line 162) | E() :
    method E (line 165) | E(const E & rhs) :
  class F (line 172) | class F {
    method serialize (line 176) | void serialize(Archive &ar, const unsigned int /*file_version*/){
    method F (line 183) | F & operator=(const F & rhs) {
    method F (line 187) | F(){
    method F (line 190) | F(const F & rhs){
  function test4 (line 200) | void test4(){
  class G (line 220) | class G {
    method save (line 226) | void save(Archive &ar, const unsigned int /*file_version*/) const {
    method load (line 232) | void load(Archive &ar, const unsigned int /*file_version*/){
    method G (line 250) | G & operator=(const G & rhs) {
    method G (line 256) | G(){
    method G (line 259) | G(const G & rhs){
  function test5 (line 267) | void test5(){
  type foo (line 286) | struct foo
    method serialize (line 294) | void serialize(Archive &,const unsigned int)
  type bar (line 299) | struct bar
    method save (line 309) | void save(Archive& ar,const unsigned int)const
    method load (line 321) | void load(Archive& ar,const unsigned int)
  function test6 (line 336) | int test6()
  function test7 (line 364) | void test7(){
  function test8 (line 386) | void test8(){
  function test_main (line 408) | int test_main(int /* argc */, char * /* argv */[])

FILE: test/test_set.cpp
  type std (line 21) | namespace std{
  type std (line 28) | namespace std{
  function test_set (line 43) | void
  function test_multiset (line 75) | void
  function test_main (line 106) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_set_hashed.cpp
  type std (line 23) | namespace std{
  type BOOST_STD_EXTENSION_NAMESPACE (line 43) | namespace BOOST_STD_EXTENSION_NAMESPACE {
    type hash<A> (line 45) | struct hash<A> {
  function test_hash_set (line 52) | void
  function test_hash_multiset (line 84) | void
  function test_main (line 116) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_shared_ptr.cpp
  type std (line 17) | namespace std{
  class A (line 31) | class A
    method serialize (line 37) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method A (line 47) | A(){++count;}
  class B (line 56) | class B : public A
    method serialize (line 61) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method B (line 66) | B() : A() {}
  class C (line 75) | class C
    method serialize (line 81) | void serialize(Archive & ar, const unsigned int /* file_version */){
    method C (line 89) | C() :
  function save (line 98) | void save(const char * testfile, const SP & spa)
  function load (line 106) | void load(const char * testfile, SP & spa)
  function save_and_load (line 115) | void save_and_load(SP & spa)
  function save2 (line 131) | void save2(
  function load2 (line 143) | void load2(
  function save_and_load2 (line 158) | void save_and_load2(SP & first, SP & second)
  function save3 (line 176) | void save3(
  function load3 (line 190) | void load3(
  function save_and_load3 (line 207) | void save_and_load3(
  function save4 (line 230) | void save4(const char * testfile, const SP & spc)
  function load4 (line 238) | void load4(const char * testfile, SP & spc)
  function save_and_load4 (line 247) | void save_and_load4(SP & spc)
  function test (line 264) | bool test(){
  function test_main (line 313) | int test_main(int /* argc */, char * /* argv */[])

FILE: test/test_shared_ptr_132.cpp
  type std (line 17) | namespace std{
  class A (line 36) | class A
    method save (line 42) | void save(Archive & ar, const unsigned int /* file_version */) const {
    method load (line 46) | void load(Archive & ar, const unsigned int /* file_version */) {
    method A (line 55) | A(){++count;}
  class B (line 62) | class B : public A
    method save (line 67) | void save(Archive & ar, const unsigned int /* file_version */ )const {
    method load (line 71) | void load(Archive & ar, const unsigned int /* file_version */){
    method B (line 77) | B() : A() {}
  function save (line 88) | void save(const char * testfile, const T & spa)
  function load (line 96) | void load(const char * testfile, T & spa)
  function save_and_load (line 105) | void save_and_load(const T & spa)
  function save2 (line 125) | void save2(
  function load2 (line 137) | void load2(
  function save_and_load2 (line 152) | void save_and_load2(T & first, T & second)
  function save3 (line 171) | void save3(
  function load3 (line 185) | void load3(
  function test_main (line 202) | int test_main(int /* argc */, char * /* argv */[])

FILE: test/test_shared_ptr_multi_base.cpp
  type std (line 17) | namespace std{
  type Base1 (line 30) | struct Base1 {
    method Base1 (line 31) | Base1() {}
    method Base1 (line 32) | Base1(int x) : m_x(1 + x) {}
    method serialize (line 39) | void serialize(Archive &ar, const unsigned int /* file_version */)
  type Base2 (line 45) | struct Base2 {
    method Base2 (line 46) | Base2() {}
    method Base2 (line 47) | Base2(int x) : m_x(2 + x) {}
    method serialize (line 54) | void serialize(Archive &ar, const unsigned int /* file_version */)
  type Base3 (line 60) | struct Base3 {
    method Base3 (line 61) | Base3() {}
    method Base3 (line 62) | Base3(int x) : m_x(3 + x) {}
    method serialize (line 69) | void serialize(Archive &ar, const unsigned int /* file_version */)
  type Sub (line 76) | struct Sub:public Base1, public Base2, public Base3 {
    method Sub (line 78) | Sub() {
    method Sub (line 81) | Sub(int x) :
    method Sub (line 88) | Sub(const Sub & rhs) :
    method serialize (line 101) | void serialize(Archive &ar, const unsigned int /* file_version */)
  function save2 (line 117) | void save2(
  function load2 (line 129) | void load2(
  function dynamic_pointer_cast (line 145) | boost::shared_ptr<T> dynamic_pointer_cast(boost::shared_ptr<U> const & u)
  function dynamic_pointer_cast (line 153) | std::shared_ptr<T> dynamic_pointer_cast(std::shared_ptr<U> const & u)
  function shared_weak (line 164) | void shared_weak(
  function weak_shared (line 197) | void weak_shared(
  function test (line 227) | bool test(){
  function test_main (line 294) | int test_main(int /* argc */, char * /* argv */[])

FILE: test/test_simple_class.cpp
  type std (line 24) | namespace std{
  function test_main (line 67) | int

FILE: test/test_simple_class_ptr.cpp
  type std (line 17) | namespace std{
  function test_main (line 27) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_singleton.cpp
  type A (line 18) | struct A {
    method A (line 20) | A() : m_id(++i) {}
  type B (line 27) | struct B {
    method B (line 29) | B() : m_id(++i) {}
  type C (line 36) | struct C {
    method C (line 38) | C() : m_id(++i) {}
  type D (line 45) | struct D {
    method D (line 47) | D(){
  function test_main (line 69) | int test_main(int, char *[]){

FILE: test/test_singleton_inherited.cpp
  type ConstructionState (line 30) | enum ConstructionState{CS_UNINIT, CS_INIT, CS_DESTROYED}
  type controller (line 34) | struct controller{
    method controller (line 35) | static controller& getInstance(){
    method controller (line 41) | controller() {
  type Foo (line 48) | struct Foo: boost::serialization::singleton<Foo>{
    method Foo (line 49) | Foo(): i(42) {
  function test_main (line 71) | int

FILE: test/test_singleton_plain.cpp
  type ConstructionState (line 29) | enum ConstructionState{CS_UNINIT, CS_INIT, CS_DESTROYED}
  type controller (line 33) | struct controller{
    method controller (line 34) | static controller& getInstance(){
    method controller (line 40) | controller() {
  type Foo (line 47) | struct Foo{
    method Foo (line 48) | Foo(): i(42) {
  function test_main (line 69) | int

FILE: test/test_slist.cpp
  type std (line 17) | namespace std{
  function test_slist (line 29) | void test_slist(){
  function test_main (line 48) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_slist_ptrs.cpp
  type std (line 17) | namespace std{
  type ptr_equal_to (line 35) | struct ptr_equal_to {
  function test_slist (line 48) | void test_slist(){
  function test_main (line 82) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_smart_cast.cpp
  class Base1 (line 18) | class Base1 : public boost::noncopyable
  class Base2 (line 23) | class Base2
  class Derived (line 33) | class Derived : public Base1, public Base2
  function test_static_reference_cast_2 (line 46) | void test_static_reference_cast_2(){
  function test_static_reference_cast_1 (line 70) | void test_static_reference_cast_1(){
  function test_static_pointer_cast (line 94) | void test_static_pointer_cast(){
  class VBase1 (line 120) | class VBase1 : public boost::noncopyable
  class VBase2 (line 127) | class VBase2
  class VDerived (line 139) | class VDerived : public VBase1, public VBase2
  function test_dynamic_reference_cast_2 (line 152) | void test_dynamic_reference_cast_2(){
  function test_dynamic_reference_cast_1 (line 176) | void test_dynamic_reference_cast_1(){
  function test_dynamic_pointer_cast (line 200) | void test_dynamic_pointer_cast(){
  function test_main (line 225) | int

FILE: test/test_split.cpp
  type std (line 17) | namespace std{
  class A (line 27) | class A
    method save (line 31) | void save(
    method load (line 38) | void load(
    method A (line 47) | A() : count(0) {}
  class B (line 53) | class B
    method save (line 57) | void save(
    method load (line 64) | void load(
    method B (line 72) | B() : count(0) {}
  type boost (line 80) | namespace boost {
    type serialization (line 81) | namespace serialization {
      function serialize (line 84) | void serialize(
      function save (line 109) | void save(
      function load (line 118) | void load(
    type serialization (line 106) | namespace serialization {
      function serialize (line 84) | void serialize(
      function save (line 109) | void save(
      function load (line 118) | void load(
  class C (line 95) | class C
    method C (line 99) | C() : count(0) {}
  type boost (line 105) | namespace boost {
    type serialization (line 81) | namespace serialization {
      function serialize (line 84) | void serialize(
      function save (line 109) | void save(
      function load (line 118) | void load(
    type serialization (line 106) | namespace serialization {
      function serialize (line 84) | void serialize(
      function save (line 109) | void save(
      function load (line 118) | void load(
  function out (line 131) | void out(const char *testfile, A & a, B & b, C & c)
  function in (line 140) | void in(const char *testfile, A & a, B & b, C & c)
  function test_main (line 149) | int

FILE: test/test_stack.cpp
  type std (line 17) | namespace std{
  function test_main (line 31) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_static_warning.cpp
  class polymorphic (line 19) | class polymorphic {
  class non_polymorphic (line 23) | class non_polymorphic {
  function f (line 27) | int f(){
  type A (line 32) | struct A {
  function main (line 52) | int main(int /* argc */, char * /* argv */[]){

FILE: test/test_strong_typedef.cpp
  type type1 (line 36) | struct type1
  type not_noexcept (line 52) | struct not_noexcept
    method not_noexcept (line 54) | not_noexcept() {}
    method not_noexcept (line 55) | not_noexcept(not_noexcept const&) {}
    method not_noexcept (line 56) | not_noexcept& operator=(not_noexcept const&) {return *this;}
  function main (line 68) | int main()

FILE: test/test_tools.hpp
  type boost (line 32) | namespace boost {
    type archive (line 33) | namespace archive {
    type archive (line 78) | namespace archive {
    type archive (line 125) | namespace archive {
    type archive (line 140) | namespace archive {
    type detail (line 172) | namespace detail {
      function msg_impl (line 173) | inline void msg_impl(char const * msg, char const * file, int line, ...
  type std (line 54) | namespace std{
  type boost (line 77) | namespace boost {
    type archive (line 33) | namespace archive {
    type archive (line 78) | namespace archive {
    type archive (line 125) | namespace archive {
    type archive (line 140) | namespace archive {
    type detail (line 172) | namespace detail {
      function msg_impl (line 173) | inline void msg_impl(char const * msg, char const * file, int line, ...
  type boost (line 124) | namespace boost {
    type archive (line 33) | namespace archive {
    type archive (line 78) | namespace archive {
    type archive (line 125) | namespace archive {
    type archive (line 140) | namespace archive {
    type detail (line 172) | namespace detail {
      function msg_impl (line 173) | inline void msg_impl(char const * msg, char const * file, int line, ...
  type boost (line 139) | namespace boost {
    type archive (line 33) | namespace archive {
    type archive (line 78) | namespace archive {
    type archive (line 125) | namespace archive {
    type archive (line 140) | namespace archive {
    type detail (line 172) | namespace detail {
      function msg_impl (line 173) | inline void msg_impl(char const * msg, char const * file, int line, ...
  type boost (line 172) | namespace boost { namespace detail {
    type archive (line 33) | namespace archive {
    type archive (line 78) | namespace archive {
    type archive (line 125) | namespace archive {
    type archive (line 140) | namespace archive {
    type detail (line 172) | namespace detail {
      function msg_impl (line 173) | inline void msg_impl(char const * msg, char const * file, int line, ...
  function main (line 196) | int
  function BOOST_CATCH (line 205) | BOOST_CATCH(const std::exception & e){
  function BOOST_CATCH (line 209) | BOOST_CATCH(...){

FILE: test/test_tracking.cpp
  type std (line 17) | namespace std{
  function out (line 49) | void out(const char *testfile)
  function in (line 78) | void in(const char *testfile)
  function test_main (line 119) | int

FILE: test/test_traits_fail.cpp
  class A (line 14) | class A
  class B (line 26) | class B
  function test_main (line 34) | int

FILE: test/test_traits_pass.cpp
  class B (line 16) | class B
  function test_main (line 24) | int

FILE: test/test_unique_ptr.cpp
  type std (line 13) | namespace std{
  class A (line 23) | class A
    method serialize (line 29) | void serialize(Archive &ar, const unsigned int /* file_version */){
    method A (line 33) | A(){}
  function test_main (line 40) | int test_main(int /* argc */, char * /* argv */[]){
  function test_main (line 66) | int test_main(int /* argc */, char * /* argv */[]){

FILE: test/test_unregistered.cpp
  type std (line 18) | namespace std{
  class polymorphic_base (line 30) | class polymorphic_base
    method serialize (line 34) | void serialize(Archive & /* ar */, const unsigned int /* file_version ...
  class polymorphic_derived1 (line 40) | class polymorphic_derived1 : public polymorphic_base
    method serialize (line 44) | void serialize(Archive &ar, const unsigned int /* file_version */){
  class polymorphic_derived2 (line 49) | class polymorphic_derived2 : public polymorphic_base
    method serialize (line 53) | void serialize(Archive &ar, const unsigned int /* file_version */){
  type type1 (line 58) | struct type1 {
    method serialize (line 60) | void serialize(Archive&, unsigned int ver) {
  type type2 (line 64) | struct type2 {
    method serialize (line 66) | void serialize(Archive&, unsigned int ver) {
  function save_unregistered1 (line 75) | void save_unregistered1(const char *testfile)
  function BOOST_CATCH (line 88) | BOOST_CATCH(boost::archive::archive_exception const& aex){
  function load_unregistered1 (line 102) | void load_unregistered1(const char *testfile)
  function BOOST_CATCH (line 115) | BOOST_CATCH(boost::archive::archive_exception const& aex){
  function save_unregistered2 (line 130) | void save_unregistered2(const char *testfile)
  function BOOST_CATCH (line 143) | BOOST_CATCH(boost::archive::archive_exception const& aex){
  function load_unregistered2 (line 156) | void load_unregistered2(const char *testfile)
  function BOOST_CATCH (line 169) | BOOST_CATCH(boost::archive::archive_exception const& aex){
  function save_registered (line 183) | void save_registered(const char *testfile)
  function load_registered (line 203) | void load_registered(const char *testfile)
  function save_unregistered_pointer (line 248) | void save_unregistered_pointer(const char *testfile)
  function BOOST_CATCH (line 261) | BOOST_CATCH(...) {
  function load_unregistered_pointer (line 270) | void load_unregistered_pointer(const char *testfile)
  function BOOST_CATCH (line 282) | BOOST_CATCH(boost::archive::archive_exception const& aex){
  function test_main (line 296) | int

FILE: test/test_valarray.cpp
  type std (line 17) | namespace std{
  function test_main (line 26) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_variant.cpp
  type std (line 32) | namespace std {
  type boost (line 53) | namespace boost {
    class static_visitor (line 54) | class static_visitor
  class are_equal (line 60) | class are_equal
    type same (line 67) | struct same {
      method invoke (line 69) | static bool invoke(const T & t, const U & u){
    type not_same (line 74) | struct not_same {
      method invoke (line 76) | static bool invoke(const T &, const U &){
  function test_type (line 116) | bool test_type(const Variant & v){
  function test (line 143) | void test(Variant & v)
  function test_boost_variant (line 167) | int test_boost_variant(){
  function test_boost_variant2 (line 181) | int test_boost_variant2(){
  function test_std_variant (line 195) | int test_std_variant(){
  function test_main (line 206) | int test_main( int /* argc */, char* /* argv */[] ){

FILE: test/test_vector.cpp
  type std (line 17) | namespace std{
  function test_vector_detail (line 31) | int test_vector_detail(const std::vector<T> & avector)
  function test_default_constructible (line 54) | int test_default_constructible()
  type X (line 64) | struct X {
    method X (line 68) | X(const X & x) :
    method X (line 71) | X(const int & i) :
    method serialize (line 78) | void serialize(Archive & ar, const unsigned int /*version*/){
  function save_construct_data (line 84) | inline void save_construct_data(
  function load_construct_data (line 94) | inline void load_construct_data(
  function test_non_default_constructible (line 104) | int test_non_default_constructible()
  function test_main (line 113) | int test_main( int /* argc */, char* /* argv */[] )

FILE: test/test_void_cast.cpp
  class Base1 (line 16) | class Base1
  class Base2 (line 21) | class Base2
  class Derived (line 26) | class Derived : public Base1, public Base2
  class MostDerived (line 31) | class MostDerived : public Derived
  function test_main (line 43) | int

FILE: test/test_z.cpp
  type Foo (line 11) | struct Foo
    method Foo (line 13) | Foo(int aBar) :
    method bar (line 21) | int bar() const
  type boost (line 32) | namespace boost {
    type serialization (line 33) | namespace serialization {
      function serialize (line 36) | inline void serialize(Archive & ar, Foo& foo, const unsigned int /*v...
      function save_construct_data (line 42) | inline void save_construct_data(Archive & ar, const Foo* foo, const ...
      function load_construct_data (line 49) | inline void load_construct_data(Archive & ar, Foo* foo, const unsign...
    type archive (line 678) | namespace archive
      class detail::archive_serializer_map<xml_iarchive_nan> (line 680) | class detail::archive_serializer_map<xml_iarchive_nan>
      class detail::interface_iarchive<xml_iarchive_nan> (line 681) | class detail::interface_iarchive<xml_iarchive_nan>
      class detail::common_iarchive<xml_iarchive_nan> (line 682) | class detail::common_iarchive<xml_iarchive_nan>
      class basic_xml_iarchive<xml_iarchive_nan> (line 683) | class basic_xml_iarchive<xml_iarchive_nan>
      class xml_iarchive_impl<xml_iarchive_nan> (line 684) | class xml_iarchive_impl<xml_iarchive_nan>
  function main (line 61) | int main()
  type std (line 94) | namespace std{
  function test_main (line 110) | int test_main( int /* argc */, char* /* argv */[] )
  function test_main (line 151) | int test_main(int, char *argv[])
  function main (line 191) | int main() {
  type boxed_int (line 208) | struct boxed_int
    method boxed_int (line 210) | boxed_int() : i(0) {}
    method boxed_int (line 211) | boxed_int(int i) : i(i) {}
    method serialize (line 214) | void serialize(Archive &ar, unsigned version)
  function go (line 221) | void go(std::istream &is) {
  function main (line 231) | int main(int argc, char **argv) {
  function main (line 251) | int main()
  type S (line 566) | struct S
    method serialize (line 572) | void serialize(Archive & ar, const unsigned int version)
  function main (line 579) | int main()
  function f (line 607) | void f()
  function main (line 615) | int main(int argc, char* argv[])
  class xml_iarchive_nan (line 630) | class xml_iarchive_nan :
    method load (line 640) | void load(double & t)
    method xml_iarchive_nan (line 668) | xml_iarchive_nan(std::istream & is, unsigned int flags = 0) :
  type boost (line 676) | namespace boost
    type serialization (line 33) | namespace serialization {
      function serialize (line 36) | inline void serialize(Archive & ar, Foo& foo, const unsigned int /*v...
      function save_construct_data (line 42) | inline void save_construct_data(Archive & ar, const Foo* foo, const ...
      function load_construct_data (line 49) | inline void load_construct_data(Archive & ar, Foo* foo, const unsign...
    type archive (line 678) | namespace archive
      class detail::archive_serializer_map<xml_iarchive_nan> (line 680) | class detail::archive_serializer_map<xml_iarchive_nan>
      class detail::interface_iarchive<xml_iarchive_nan> (line 681) | class detail::interface_iarchive<xml_iarchive_nan>
      class detail::common_iarchive<xml_iarchive_nan> (line 682) | class detail::common_iarchive<xml_iarchive_nan>
      class basic_xml_iarchive<xml_iarchive_nan> (line 683) | class basic_xml_iarchive<xml_iarchive_nan>
      class xml_iarchive_impl<xml_iarchive_nan> (line 684) | class xml_iarchive_impl<xml_iarchive_nan>
  function main (line 689) | int main(int argc, char** argv)
  type Tracked (line 710) | struct Tracked {
    method Tracked (line 712) | Tracked(std::string s) : x(s) {}
    method Tracked (line 713) | Tracked() : x("tracked"){}
    method serialize (line 714) | void serialize(A& ar, unsigned int ) {
  type Main (line 719) | struct Main {
    method Main (line 723) | Main() : t_before("before"), t_pointer(0), t_after("after") {}
    method serialize (line 724) | void serialize(A& ar, unsigned int ) {
  function main (line 735) | int main(int argc, char *argv[])
  function main (line 780) | int main() {
  function main (line 805) | int main(int argc, char* argv[])