src/main/decaf/lang/Pointer.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _DECAF_LANG_POINTER_H_
#define _DECAF_LANG_POINTER_H_

#include <decaf/util/Config.h>
#include <decaf/lang/exceptions/NullPointerException.h>
#include <decaf/lang/exceptions/ClassCastException.h>
#include <decaf/util/concurrent/atomic/AtomicRefCounter.h>
#include <decaf/util/Comparator.h>
#include <memory>
#include <typeinfo>
#include <algorithm>
#include <functional>

namespace decaf {
namespace lang {

    // Used internally in Pointer.
    struct STATIC_CAST_TOKEN {};
    struct DYNAMIC_CAST_TOKEN {};

    template< typename T, typename REFCOUNTER = decaf::util::concurrent::atomic::AtomicRefCounter >
    class Pointer : public REFCOUNTER {
    private:

        typedef void (*deletionFuncPtr)(T* p);

    private:

        T* value;

        // Pointer to our internal delete function, allows incompletes.
        deletionFuncPtr onDelete;

    public:

        typedef T* PointerType;          // type returned by operator->
        typedef T& ReferenceType;        // type returned by operator*
        typedef REFCOUNTER CounterType;  // Type of the Reference Counter

    public:

        Pointer() : REFCOUNTER(), value( NULL ), onDelete( onDeleteFunc ) {}

        explicit Pointer( const PointerType value ) : REFCOUNTER(), value( value ), onDelete( onDeleteFunc ) {
        }

        Pointer( const Pointer& value ) throw() :
            REFCOUNTER( value ), value( value.value ), onDelete( onDeleteFunc ) {}

        template< typename T1, typename R1 >
        Pointer( const Pointer<T1, R1>& value ) throw() :
            REFCOUNTER( value ), value( value.get() ), onDelete( onDeleteFunc ) {}

        template< typename T1, typename R1 >
        Pointer( const Pointer<T1, R1>& value, const STATIC_CAST_TOKEN& ) throw() :
            REFCOUNTER( value ), value( static_cast<T*>( value.get() ) ), onDelete( onDeleteFunc ) {
        }

        template< typename T1, typename R1 >
        Pointer( const Pointer<T1, R1>& value, const DYNAMIC_CAST_TOKEN& ) :
                REFCOUNTER( value ), value( dynamic_cast<T*>( value.get() ) ), onDelete( onDeleteFunc ) {

            if( this->value == NULL ) {

                // Remove the reference we took in the Reference Counter's ctor since we
                // didn't actually create one as the dynamic cast failed.
                REFCOUNTER::release();
                throw decaf::lang::exceptions::ClassCastException(
                    __FILE__, __LINE__,
                    "Failed to cast source pointer of type %s to this type: %s.",
                    typeid( T1 ).name(), typeid( T ).name() );
            }
        }

        virtual ~Pointer() throw() {
            if( REFCOUNTER::release() == true ) {
                onDelete( this->value );
            }
        }

        void reset( T* value ) {
            Pointer( value ).swap( *this );
        }

        T* release() {
            T* temp = this->value;
            this->value = NULL;
            return temp;
        }

        PointerType get() const {
            return this->value;
        }

        void swap( Pointer& value ) throw() {
            std::swap( this->value, value.value );
            REFCOUNTER::swap( value );
        }

        Pointer& operator= ( const Pointer& right ) throw() {
            if( this == (void*)&right ) {
                return *this;
            }

            Pointer temp( right );
            temp.swap( *this );
            return *this;
        }
        template< typename T1, typename R1>
        Pointer& operator= ( const Pointer<T1, R1>& right ) throw() {
            if( this == (void*)&right ) {
                return *this;
            }

            Pointer temp( right );
            temp.swap( *this );
            return *this;
        }

        ReferenceType operator*() {
            if( this->value == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "Pointer operator& - Pointee is NULL." );
            }

            return *( this->value );
        }
        ReferenceType operator*() const {
            if( this->value == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "Pointer operator& - Pointee is NULL." );
            }

            return *( this->value );
        }

        PointerType operator->() {
            if( this->value == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "Pointer operator-> - Pointee is NULL." );
            }
            return this->value;
        }
        PointerType operator->() const {
            if( this->value == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "Pointer operator-> - Pointee is NULL." );
            }
            return this->value;
        }

        bool operator!() const {
            return this->value == NULL;
        }

        inline friend bool operator==( const Pointer& left, const T* right ) {
            return left.get() == right;
        }

        inline friend bool operator==( const T* left, const Pointer& right ) {
            return left == right.get();
        }

        inline friend bool operator!=( const Pointer& left, const T* right ) {
            return left.get() != right;
        }

        inline friend bool operator!=( const T* left, const Pointer& right ) {
            return left != right.get();
        }

        template< typename T1, typename R1 >
        bool operator==( const Pointer<T1, R1>& right ) const {
            return this->value == right.get();
        }

        template< typename T1, typename R1 >
        bool operator!=( const Pointer<T1, R1>& right ) const {
            return !( this->value == right.get() );
        }

        template< typename T1 >
        Pointer<T1, CounterType> dynamicCast() const {
            return Pointer<T1, CounterType>( *this, DYNAMIC_CAST_TOKEN() );
        }

        template< typename T1 >
        Pointer<T1, CounterType> staticCast() const {
            return Pointer<T1, CounterType>( *this, STATIC_CAST_TOKEN() );
        }

    private:

        // Internal Static deletion function.
        static void onDeleteFunc(T* value) {
            delete value;
        }

    };

    template< typename T, typename R, typename U >
    inline bool operator==( const Pointer<T, R>& left, const U* right ) {
        return left.get() == right;
    }

    template< typename T, typename R, typename U >
    inline bool operator==( const U* left, const Pointer<T, R>& right ) {
        return right.get() == left;
    }

    template< typename T, typename R, typename U >
    inline bool operator!=( const Pointer<T, R>& left, const U* right ) {
        return !( left.get() == right );
    }

    template< typename T, typename R, typename U >
    inline bool operator!=( const U* left, const Pointer<T, R>& right ) {
        return right.get() != left;
    }

    template< typename T, typename R = decaf::util::concurrent::atomic::AtomicRefCounter >
    class PointerComparator : public decaf::util::Comparator< Pointer<T,R> > {
    public:

        virtual ~PointerComparator() {}

        // Allows for operator less on types that implement Comparable or provide
        // a workable operator <
        virtual bool operator() ( const Pointer<T,R>& left, const Pointer<T,R>& right ) const {
            return *left < *right;
        }

        // Requires that the type in the pointer is an instance of a Comparable.
        virtual int compare( const Pointer<T,R>& left, const Pointer<T,R>& right ) const {
            return *left < *right ? -1 : *right < *left ? 1 : 0;
        }

    };

}}

namespace std{

    template< typename T >
    struct less< decaf::lang::Pointer<T> > :
        public binary_function< decaf::lang::Pointer<T>,
                                decaf::lang::Pointer<T>, bool>
    {
        bool operator()( const decaf::lang::Pointer<T>& left,
                         const decaf::lang::Pointer<T>& right ) const
        {
            return less<T*>()( left.get(), right.get() );
        }
    };
}

#endif /*_DECAF_LANG_POINTER_H_*/