// Copyright David Abrahams 2008. Distributed under the Boost
// Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include "boost/utility/enable_if.hpp"
#include "boost/mpl/bool.hpp"

namespace boost
{
  template <class T>
  struct range_iterator
  {
      typedef typename T::iterator type;
  };

  template <class T>
  struct range_iterator<T const>
    : range_iterator<T>
  {};
}

namespace my
{
  struct range1 { range1() {} };
  int* range_begin(range1 const& r) { return 0; }

  struct range2
  {
      range2() {}
      
      typedef char* iterator;
      char* begin() const { return 0; }
  };
}

namespace boost
{
  template <>
  struct range_iterator<my::range1>
  {
      typedef int* type;
  };
}

namespace boost
{
  namespace range_detail
  {
    typedef char (&false_)[2];
    typedef char true_;
    
    struct not_overloaded {};
    not_overloaded operator,(not_overloaded,int);
    
    template <class T>
    not_overloaded range_begin(T const&);
        
    template <class T>
    true_ is_overloaded(T const&);

    false_ is_overloaded(not_overloaded);

    template <class T>
    T& make();
    
    template <class R>
    struct range_begin_overloaded
      : mpl::bool_< (sizeof(range_detail::is_overloaded(
                                (range_begin(make<R const>()),3)
                            ))) == 1 >
    {
    };
  }
  
  namespace begin_
  {
    template <class R>
    typename lazy_disable_if<range_detail::range_begin_overloaded<R>, range_iterator<R> >::type
    range_begin(R& r) { return r.begin(); }
    
    template <class R>
    typename lazy_disable_if<range_detail::range_begin_overloaded<R>, range_iterator<R> >::type
    range_begin(R const& r) { return r.begin(); }
    
    template <class R>
    typename range_iterator<R>::type begin(R& r) { return range_begin(r); }

    template <class R>
    typename range_iterator<R>::type begin(R const& r) { return range_begin(r); }
  }
  using begin_::begin;
};


namespace your
{
  
  int* z0 = boost::begin(my::range1());

  my::range1 x0;
  int* z1 = boost::begin(x0);

  my::range1 const x1;
  int* z2 = boost::begin(x1);

  char* w0 = boost::begin(my::range2());

  my::range2 y0;
  char* w1 = boost::begin(y0);

  my::range2 const y1;
  char* w2 = boost::begin(y1);

}

int main() {}