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/AtomicRefCounter.h>
#include <decaf/util/Comparator.h>
#include <decaf/util/Arrays.h>
#include <memory>
#include <typeinfo>
#include <algorithm>

namespace decaf {
namespace lang {

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

        struct ArrayData {
            T* value;
            int length;

            ArrayData() : value( NULL ), length( 0 ) {}
            ArrayData( T* value, int length ) : value( value ), length( length ) {
                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" );
                }
            }
        };

        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*
        typedef REFCOUNTER CounterType;      // Type of the Reference Counter

    public:

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

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

            if( size == 0 ) {
                return;
            }

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

        ArrayPointer( int size, const T& fillWith ) :
            REFCOUNTER(), 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 ) {
                REFCOUNTER::release();
                throw ex;
            } catch(...) {
                REFCOUNTER::release();
                throw std::bad_alloc();
            }
        }

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

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

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

        virtual ~ArrayPointer() throw() {
            if( REFCOUNTER::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;
            return temp;
        }

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

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

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

        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 ) throw() {
            if( this == (void*)&right ) {
                return *this;
            }

            ArrayPointer temp( right );
            temp.swap( *this );
            return *this;
        }
        template< typename T1, typename R1>
        ArrayPointer& operator= ( const ArrayPointer<T1, R1>& right ) throw() {
            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, typename R1 >
        bool operator==( const ArrayPointer<T1, R1>& right ) const {
            return this->array->value == right.get();
        }

        template< typename T1, typename R1 >
        bool operator!=( const ArrayPointer<T1, R1>& 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 R, typename U >
    inline bool operator==( const ArrayPointer<T, R>& left, const U* right ) {
        return left.get() == right;
    }

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

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

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

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

        virtual ~ArrayPointerComparator() {}

        // Allows for operator less on types that implement Comparable or provide
        // a workable operator <
        virtual bool operator() ( const ArrayPointer<T,R>& left, const ArrayPointer<T,R>& 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,R>& left, const ArrayPointer<T,R>& 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> > :
        public binary_function< decaf::lang::ArrayPointer<T>,
                                decaf::lang::ArrayPointer<T>, bool>
    {
        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_*/