src/main/decaf/lang/ArrayPointer.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_ARRAYPOINTER_H_
#define _DECAF_LANG_ARRAYPOINTER_H_

#include <decaf/util/Config.h>
#include <decaf/lang/System.h>
#include <decaf/lang/exceptions/NullPointerException.h>
#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>
#include <decaf/lang/exceptions/IllegalArgumentException.h>
#include <decaf/util/concurrent/atomic/AtomicInteger.h>
#include <decaf/util/Comparator.h>
#include <decaf/util/Arrays.h>
#include <memory>
#include <typeinfo>
#include <algorithm>

namespace decaf {
namespace lang {

    template< typename T >
    class ArrayPointer {
    private:

        struct ArrayData {
        private:

            ArrayData(const ArrayData&);
            ArrayData& operator= (const ArrayData&);

        public:

            T* value;
            int length;
            decaf::util::concurrent::atomic::AtomicInteger refs;

            ArrayData() : value(NULL), length(0), refs(1) {}
            ArrayData(T* value, int length) : value(value), length(length), refs(1) {
                if( value != NULL && length <= 0 ) {
                    throw decaf::lang::exceptions::IllegalArgumentException(
                        __FILE__, __LINE__, "Non-NULL array pointer cannot have a size <= zero" );
                }

                if( value == NULL && length > 0 ) {
                    throw decaf::lang::exceptions::IllegalArgumentException(
                        __FILE__, __LINE__, "NULL array pointer cannot have a size > zero" );
                }
            }

            bool release() {
                if (this->refs.decrementAndGet() < 1) {
                    return true;
                }
                return false;
            }
        };

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

    private:

        ArrayData* array;

        // 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 const T& ConstReferenceType; // type returned by const operator*

    public:

        ArrayPointer() : array(new ArrayData()), onDelete(onDeleteFunc) {}

        ArrayPointer(int size) : array(NULL), onDelete(onDeleteFunc) {

            if (size == 0) {
                return;
            }

            try {
                T* value = new T[size];
                this->array = new ArrayData(value, size);
                decaf::util::Arrays::fill(value, size, 0, size, T());
            } catch (std::exception& ex) {
                throw ex;
            } catch (...) {
                throw std::bad_alloc();
            }
        }

        ArrayPointer(int size, const T& fillWith) : array(NULL), onDelete(onDeleteFunc) {

            if (size == 0) {
                return;
            }

            try {
                T* value = new T[size];
                decaf::util::Arrays::fill(value, size, 0, size, fillWith);
                this->array = new ArrayData(value, size);
            } catch (std::exception& ex) {
                throw ex;
            } catch (...) {
                throw std::bad_alloc();
            }
        }

        explicit ArrayPointer(const PointerType value, int size) : array(NULL), onDelete(onDeleteFunc) {

            try {
                this->array = new ArrayData(value, size);
            } catch (std::exception& ex) {
                throw ex;
            } catch (...) {
                throw std::bad_alloc();
            }
        }

        ArrayPointer(const ArrayPointer& value) : array(value.array), onDelete(onDeleteFunc) {
            this->array->refs.incrementAndGet();
        }

        virtual ~ArrayPointer() {
            if (this->array->release() == true) {
                onDelete(this->array);
            }
        }

        void reset(T* value, int size = 0) {
            ArrayPointer(value, size).swap(*this);
        }

        T* release() {
            T* temp = this->array->value;
            this->array->value = NULL;
            this->array->length = 0;
            this->array->refs.set(1);
            return temp;
        }

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

        int length() const {
            return this->array->length;
        }

        void swap(ArrayPointer& value) {
            std::swap(this->array, value.array);
        }

        ArrayPointer clone() const {

            if (this->array->length == 0) {
                return ArrayPointer();
            }

            ArrayPointer copy(this->array->length);
            decaf::lang::System::arraycopy(this->array->value, 0, copy.get(), 0, this->array->length);
            return copy;
        }

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

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

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

        ReferenceType operator[](int index) {
            if (this->array->value == NULL) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "ArrayPointer operator& - Pointee is NULL." );
            }

            if (index < 0 || this->array->length <= index) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__, "Array Index %d is out of bounds for this array.", this->array->length );
            }

            return this->array->value[index];
        }
        ConstReferenceType operator[](int index) const {
            if( this->array->value == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "ArrayPointer operator& - Pointee is NULL." );
            }

            if( index < 0 || this->array->length <= index ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__, "Array Index %d is out of bounds for this array.", this->array->length );
            }

            return this->array->value[index];
        }

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

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

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

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

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

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

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

    private:

        // Internal Static deletion function.
        static void onDeleteFunc(ArrayData* value) {
            delete [] value->value;
            delete value;
        }

    };

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

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

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

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

    template< typename T >
    class ArrayPointerComparator : public decaf::util::Comparator< ArrayPointer<T> > {
    public:

        virtual ~ArrayPointerComparator() {}

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

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

    };

}}

namespace std{

    template< typename T >
    struct less< decaf::lang::ArrayPointer<T> > {

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

        bool operator()(const decaf::lang::ArrayPointer<T>& left,
                        const decaf::lang::ArrayPointer<T>& right) const {
            return less<T*>()(left.get(), right.get());
        }
    };
}

#endif /*_DECAF_LANG_ARRAYPOINTER_H_*/

---