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.
        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) : REFCOUNTER(value), value(value.value), onDelete(onDeleteFunc) {}

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

        template<typename T1, typename R1>
        Pointer(const Pointer<T1, R1>& value, const STATIC_CAST_TOKEN&) :
            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() {
            if (REFCOUNTER::release() == true) {
                onDelete(this->value);
            }
        }

        void reset(T* value = NULL) {
            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) {
            std::swap(this->value, value.value);
            REFCOUNTER::swap(value);
        }

        Pointer& operator=(const Pointer& right) {
            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) {
            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>
    std::ostream& operator<<(std::ostream &out, const Pointer<T, R>& pointer) {
        out << pointer.get();
        return out;
    }

    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> {

        typedef decaf::lang::Pointer<T> first_argument_type;
        typedef decaf::lang::Pointer<T> second_argument_type;
        typedef bool result_type;

        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_*/

---