org.eclipse.efm.symbex/src/collection/Array.h

/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/
#ifndef CONTAINER_ARRAY_H_
#define CONTAINER_ARRAY_H_


#include <vector>

#include <util/avm_assert.h>
#include <util/avm_numeric.h>
#include <base/SmartPointerUtil.h>


namespace sep
{


template< typename T >
class Array
{

protected:
	/*
	 * ATTRIBUTES
	 */
	T * mTable;

	avm_size_t mSize;


public:
	/**
	 * TYPEDEF
	 * iterator
	 * reference
	 */
	typedef       T * iterator;
	typedef const T * const_iterator;

	typedef       T & reference;
	typedef const T & const_reference;

	typedef std::vector< T >  BaseVector;



	/**
	 * CONSTRUCTOR
	 * Default
	 */
	Array()
	: mTable( NULL ),
	mSize( 0 )
	{
		//!! NOTHING
	}

	explicit Array(avm_size_t aSize)
	: mTable( NULL ),
	mSize( 0 )
	{
		alloc( aSize );
	}


	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	Array(const Array & anArray)
	: mTable( NULL ),
	mSize( 0 )
	{
		alloc( anArray );
	}


	/**
	 * CONSTRUCTOR
	 * Others
	 */
	explicit Array(avm_size_t aSize, const_reference defaultValue)
	: mTable( NULL ),
	mSize( 0 )
	{
		alloc( aSize , defaultValue );
	}

	explicit Array(const BaseVector & anArray)
	: mTable( NULL ),
	mSize( 0 )
	{
		alloc( anArray );
	}

	explicit Array(const Array & anArray,
			const_reference lastValue)
	: mTable( NULL ),
	mSize( 0 )
	{
		alloc( anArray , lastValue );
	}



	/**
	 * DESTRUCTOR
	 */
	virtual ~Array()
	{
		delete[] ( mTable );

		mTable = NULL;
	}


	/*
	 ***************************************************************************
	 * RESET
	 ***************************************************************************
	 */

	void reset(T value)
	{
		for( avm_size_t offset = 0 ; offset < mSize ; ++offset )
		{
			mTable[offset] = value;
		}
	}


	/*
	 ***************************************************************************
	 * ALLOCATION
	 ***************************************************************************
	 */

	inline void alloc(avm_size_t aSize)
	{
		mSize = aSize;

		mTable = ( (mSize > 0)? (new T[ mSize ]) : NULL );
	}


	inline void alloc(avm_size_t aSize, T defaultValue)
	{
		alloc( aSize );

		for( avm_size_t offset = 0 ; offset < mSize ; ++offset )
		{
			mTable[offset] = defaultValue;
		}
	}


	inline void alloc(const Array & anArray)
	{
		alloc( anArray.size() );

		for( avm_size_t offset = 0 ; offset < mSize ; ++offset )
		{
			mTable[offset] = anArray[offset];
		}
	}


	inline void alloc(const Array & anArray, T lastValue)
	{
		avm_size_t aSize = anArray.size();
		alloc( aSize + 1 );

		for( avm_size_t offset = 0 ; offset < aSize ; ++offset )
		{
			mTable[offset] = anArray[offset];
		}
		mTable[aSize] = lastValue;

	}


	inline void alloc(const BaseVector & anArray)
	{
		alloc( anArray.size() );

		for( avm_size_t offset = 0 ; offset < mSize ; ++offset )
		{
			mTable[offset] = anArray[offset];
		}
	}



	/*
	 ***************************************************************************
	 * RE-ALLOCATION
	 ***************************************************************************
	 */

	inline void realloc(avm_size_t aSize)
	{
		if( mSize != aSize )
		{
			delete[] ( mTable );

			alloc( aSize );
		}
	}


	inline void realloc(avm_size_t aSize, T defaultValue)
	{
		if( mSize != aSize )
		{
			delete[] ( mTable );

			alloc( aSize );
		}

		reset( defaultValue );
	}


	inline void realloc(const Array & anArray)
	{
		if( mSize != anArray.size() )
		{
			delete[] ( mTable );

			alloc( anArray.size() );
		}

		for( avm_size_t offset = 0 ; offset < mSize ; ++offset )
		{
			mTable[offset] = anArray[offset];
		}
	}


	inline void realloc(const BaseVector & anArray)
	{
		if( mSize != anArray.size() )
		{
			delete[] ( mTable );

			alloc( anArray.size() );
		}

		for( avm_size_t offset = 0 ; offset < mSize ; ++offset )
		{
			mTable[offset] = anArray[offset];
		}
	}


	/*
	 ***************************************************************************
	 * RE-SIZE
	 ***************************************************************************
	 */

	inline void resize(avm_size_t aSize)
	{
		if( mSize > 0 )
		{
			avm_size_t oldSize = mSize;
			T * oldTable = mTable;

			alloc( aSize );

			if( aSize > oldSize )
			{
				aSize = oldSize;
			}

			for( avm_size_t offset = 0 ; offset < aSize ; ++offset )
			{
				mTable[offset] = oldTable[offset];
			}

			delete [] oldTable;
		}

		else
		{
			alloc(aSize);
		}
	}

	inline void resize(avm_size_t aSize, T defaultValue)
	{
		if( mSize > 0 )
		{
			avm_size_t oldSize = mSize;
			T * oldTable = mTable;

			alloc( aSize );

			if( aSize > oldSize )
			{
				aSize = oldSize;
			}

			avm_size_t offset = 0;

			for( ; offset < aSize ; ++offset )
			{
				mTable[offset] = oldTable[offset];
			}

			for( ; offset < mSize ; ++offset )
			{
				mTable[offset] = defaultValue;
			}

			delete [] oldTable;
		}

		else
		{
			alloc(aSize, defaultValue);
		}
	}


	/**
	 * ITERATOR
	 */

	inline iterator begin()
	{
		return( mTable );
	}

	inline const_iterator begin() const
	{
		return( mTable );
	}


	inline iterator succ_begin()
	{
		return( (mSize > 0)? mTable +  1 : mTable );
	}

	inline const_iterator succ_begin() const
	{
		return( (mSize > 0)? mTable +  1 : mTable );
	}


	inline iterator end()
	{
		return( mTable + mSize );
	}

	inline const_iterator end() const
	{
		return( mTable + mSize );
	}


	inline iterator pred_end()
	{
		return( (mSize > 0)? mTable + mSize - 1 : mTable );
	}

	inline const_iterator pred_end() const
	{
		return( (mSize > 0)? mTable + mSize - 1 : mTable );
	}



	/**
	 * GETTER - SETTER
	 * mTable
	 */
	inline reference at(avm_size_t offset)
	{
		AVM_OS_ASSERT_FATAL_ARRAY_INDEX_EXIT( offset , mSize ) << SEND_EXIT;

		return( mTable[offset] );
	}

	inline const_reference at(avm_size_t offset) const
	{
		AVM_OS_ASSERT_FATAL_ARRAY_INDEX_EXIT( offset , mSize ) << SEND_EXIT;

		return( mTable[offset] );
	}

	inline reference get(avm_size_t offset)
	{
		return( mTable[offset] );
	}

	inline const_reference get(avm_size_t offset) const
	{
		return( mTable[offset] );
	}


	inline void set(avm_size_t offset, const T & arg)
	{
		AVM_OS_ASSERT_FATAL_ARRAY_INDEX_EXIT( offset , mSize ) << SEND_EXIT;

		mTable[offset] = arg;
	}


	// operator[]
	inline reference operator[](avm_size_t offset)
	{
		return( mTable[offset] );
	}

	inline const_reference operator[](avm_size_t offset) const
	{
		return( mTable[offset] );
	}

	// front() and back()
	inline reference front()
	{
		return mTable[0];
	}

	inline const_reference front() const
	{
		return mTable[0];
	}

	inline reference back()
	{
		return mTable[mSize - 1];
	}

	inline const_reference back() const
	{
		return mTable[mSize - 1];
	}

	// size is constant
	inline avm_size_t size() const
	{
		return( mSize );
	}

	inline bool empty() const
	{
		return( mSize == 0 );
	}

	inline bool nonempty() const
	{
		return( mSize > 0 );
	}

	inline bool singleton() const
	{
		return( mSize == 1 );
	}

	inline bool populated() const
	{
		return( mSize > 1 );
	}


	inline reference first()
	{
		return( mTable[0] );
	}

	inline const_reference first() const
	{
		return( mTable[0] );
	}


	inline reference second()
	{
		return( mTable[1] );
	}

	inline const_reference second() const
	{
		return( mTable[1] );
	}


	inline reference third()
	{
		return( mTable[2] );
	}

	inline const_reference third() const
	{
		return( mTable[2] );
	}


	inline reference last()
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT( mSize > 0 )
				<< "last():> Unexpected an empty array !!!"
				<< SEND_EXIT;

		return( mTable[mSize - 1] );
	}

	inline const_reference last() const
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT( mSize > 0 )
				<< "last():> Unexpected an empty array !!!"
				<< SEND_EXIT;

		return( mTable[mSize - 1] );
	}

	/**
	 * contains a particular element
	 */
	inline virtual bool contains(const T & arg) const
	{
		const_iterator itEnd = end();
		for( const_iterator it = begin() ; it != itEnd ; ++it )
		{
			if( (*it) == arg )
			{
				return( true );
			}
		}

		return( false );
	}

};


}

#endif /*CONTAINER_ARRAY_H_*/