#include <string>
#include <iostream>

//  Minimal class path

class path
{
public:
  path( const char * )
  {
    std::cout << "path( const char * )\n";
  }
  path( const std::string & )
  {
    std::cout << "path( std::string & )\n";
  }

//  for maximum efficiency, either signature must work
# ifdef BY_VALUE
  operator const std::string() const
# else
  operator const std::string&() const
# endif
  {
    std::cout << "operator string\n";
    return m_path;
  }

#ifdef NAMED_CONVERSION
  std::string string() const
  {
    std::cout << "std::string string() const\n";
    return m_path;
  }
#endif

private:
  std::string m_path;
};

bool operator==( const path &, const path & )
{
  std::cout << "operator==( const path &, const path & )\n";
  return true;
}

//  These are the critical use cases. If any of these don't compile, usability
//  is unacceptably degraded.

void f( const path & )
{
  std::cout << "f( const path & )\n";
}

int main()
{
  f( "foo" );
  f( std::string( "foo" ) );
  f( path( "foo" ) );

  std::cout << '\n';

  std::string s1( path( "foo" ) );
  std::string s2 = path( "foo" );
  s2 = path( "foo" );

#ifdef NAMED_CONVERSION
  s2 = path( "foo" ).string();
#endif

  std::cout << '\n';

  // these must call bool path( const path &, const path & );
  path( "foo" ) == path( "foo" );
  path( "foo" ) == "foo";
  path( "foo" ) == std::string( "foo" );
  "foo" == path( "foo" );
  std::string( "foo" ) == path( "foo" );

  return 0;
}