text: // Boost.Convert test and usage example
  // Copyright (c) 2009-2020 Vladimir Batov.
  // Use, modification and distribution are subject to the Boost Software License,
  // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
  
  #include "./test.hpp"
  
  #if defined(BOOST_CONVERT_IS_NOT_SUPPORTED)
  int main(int, char const* []) { return 0; }
  #else
  
  #include <boost/convert.hpp>
  #include <vector>
  #include <iostream>
  
  //[has_member_declaration
  namespace { namespace local
  {
      BOOST_DECLARE_HAS_MEMBER(has_begin, begin);
      BOOST_DECLARE_HAS_MEMBER(has_funop, operator());
  }}
  //]
  //[has_member_classes_tested
  namespace { namespace local
  {
      struct test01 { int   begin; };
      struct test02 { char* begin() { return 0; } };
      struct test22 { void operator()() {} };
  }}
  //]
  
  namespace { namespace local
  {
      struct test03
      {
          void begin(int) {}
          int  begin(int, int) { return 0; }
      };
      struct test04
      {
          virtual ~test04() {}
  
          private: virtual char* begin() { return 0; }
      };
      struct test05
      {
          virtual char* begin() { return 0; }
          virtual ~test05() {}
      };
      struct test06 : public  test04 {};
      struct test07 : private test04 {};
      struct test08 : public  test05 {};
      struct test09 : private test05 {};
  
      struct test11 { int   no_begin; };
      struct test12 { char* no_begin() { return 0; } };
  }}
  
  namespace { namespace local
  {
      struct test21 { void zoo () {} };
      struct test23 { void operator() () const {} };
      struct test24 { int  operator() (int) { return 0; } };
      struct test25 { int  operator() (int) const { return 0; } };
      struct test26 { int  operator() (int) const { return 0; } void operator() () const {} };
  }}
  
  int
  main(int, char const* [])
  {
      BOOST_TEST(local::has_begin<local::test01>::value     == true);
      BOOST_TEST(local::has_begin<local::test02>::value     == true);
      BOOST_TEST(local::has_begin<local::test03>::value     == true);
      BOOST_TEST(local::has_begin<local::test04>::value     == true);
      BOOST_TEST(local::has_begin<local::test05>::value     == true);
      BOOST_TEST(local::has_begin<local::test06>::value     == true);
      BOOST_TEST(local::has_begin<local::test07>::value     == true);
      BOOST_TEST(local::has_begin<local::test08>::value     == true);
      BOOST_TEST(local::has_begin<local::test09>::value     == true);
      BOOST_TEST(local::has_begin<std::string>::value       == true);
      BOOST_TEST(local::has_begin<std::vector<int> >::value == true);
  
      BOOST_TEST(local::has_begin<local::test11>::value == false);
      BOOST_TEST(local::has_begin<local::test12>::value == false);
      BOOST_TEST(local::has_begin<std::iostream>::value == false);
  
      //[has_member_usage
      BOOST_TEST(local::has_begin<local::test01>::value == true);
      BOOST_TEST(local::has_begin<local::test02>::value == true);
      BOOST_TEST(local::has_funop<local::test22>::value == true);
      //]
  
      BOOST_TEST(local::has_funop<local::test21>::value == false);
      BOOST_TEST(local::has_funop<local::test22>::value == true);
      BOOST_TEST(local::has_funop<local::test23>::value == true);
      BOOST_TEST(local::has_funop<local::test24>::value == true);
      BOOST_TEST(local::has_funop<local::test25>::value == true);
      BOOST_TEST(local::has_funop<local::test26>::value == true);
  
      return boost::report_errors();
  }
  
  #endif
  