#include <boost/any.hpp>
#include <boost/noncopyable.hpp>

#include <cassert>

namespace boost {

    template <typename T> class any_cast2 : noncopyable {
        const any & m_any;
    public:
        explicit any_cast2( const any & v ) : m_any( v ) {}
        operator T() const { return any_cast<T>( m_any ); }
    };

    template <typename T> class any_cast2<T*> : noncopyable {
        any * const m_any;
    public:
        explicit any_cast2( any * v ) : m_any( v ) {}
        operator T * () const { return any_cast<T>( m_any ); }
    };

    template <typename T> class any_cast2<const T*> : noncopyable {
        const any * const m_any;
    public:
        explicit any_cast2( const any * v ) : m_any( v ) {}
        operator const T * () const { return any_cast<T>( m_any ); }
    };

    template <typename T> class any_cast2<T&> : noncopyable {
        any & m_any;
    public:
        explicit any_cast2( any & v ) : m_any( v ) {}
        operator T & () const { return any_cast<T&>( m_any ); }
    };

    template <typename T> class any_cast2<const T&> : noncopyable {
        const any & m_any;
    public:
        explicit any_cast2( const any & v ) : m_any( v ) {}
        operator const T & () const { return any_cast<const T&>( m_any ); }
    };


}

int main( int argc, char * argv[] ) {

    boost::any any1 = argc;

    // correct

    try { int i = boost::any_cast2<int>( any1 ); }
    catch( ... ) { assert( 0 ); }

    try { const int i = boost::any_cast2<const int>( any1 ); }
    catch( ... ) { assert( 0 ); }

    try { int * i = boost::any_cast2<int*>( &any1 ); }
    catch( ... ) { assert( 0 ); }

    try { const int * i = boost::any_cast2<const int*>( &any1 ); }
    catch( ... ) { assert( 0 ); }

    try { int & i = boost::any_cast2<int&>( any1 ); }
    catch( ... ) { assert( 0 ); }

    try { const int & i = boost::any_cast2<const int&>( any1 ); }
    catch( ... ) { assert( 0 ); }


    return 0;
}