---

oarray.h

Go to the documentation of this file.

/*
 * Copyright (c) 2001 The AUTHORS 
 *   Romeu Andre' Pieritz, Ph.D.        - romeu_pieritz@hotmail.com
 *   Rafael Mendes, Eng.                – mendes_rafael@yahoo.com
 *   Rodrigo Ferraz de Andrade, Eng.    – rferraz@iname.com 
 * All rights reserved.
 *
 * Permission to use, copy and distribute this software and its
 * documentation for educational and personal use, without fee is hereby granted, 
 * provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS
 * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE AUTHORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HERE UNDER IS
 * ON AN "AS IS" BASIS, AND THE AUTHORS HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * SINMEC Lab. - CFD Sinflow Project - http://www.sinmec.ufsc.br/cfd
 */


// File Define
#ifndef __CSFL_SYS_CORE_OARRAY_H__
#define __CSFL_SYS_CORE_OARRAY_H__

// Include 
#include <csfl/sys/core/types.h>


// Namespace
namespace csfl {


//==============================================================================
// enum TDataGravity
//==============================================================================

typedef
        enum _TDataGravity {
                dgNoGravity,
                dgNormal,
                dgStack
        }
        TDataGravity;

//==============================================================================
// template class ISimpleVectorOf<T>
// Description: template class for basic vector functionality
//==============================================================================

template <class T>
class ISimpleVectorOf
{
// ----------------------------------------------------------------------- C & D
public:
        inline ISimpleVectorOf();
        
        inline ISimpleVectorOf( int _size, const T *_data = NULL );
        inline ISimpleVectorOf( const ISimpleVectorOf<T> & );

        inline ~ISimpleVectorOf();

// ------------------------------------------------------------------- Operators
public:
        inline T & operator [] ( int );
        inline const T & operator [] ( int ) const;

        inline ISimpleVectorOf<T> & operator = ( const ISimpleVectorOf<T> & );

// --------------------------------------------------------------------- Methods
public:
        int Size() const { return size; }
        inline int SetSize( int _size, TDataGravity = dgNoGravity );
        bool IsNull() const { return data==NULL; }

        T * Data() { return data; }
        const T * Data() const { return data; }

        inline T & Data( int );
        inline const T & Data( int ) const;

        int IndexOf( const T *value ) const
                { return (value!=NULL && value>=data && value<=data+size)
                        ? value-data : -1; }

// ------------------------------------------------------------------ Attributes
protected:
        T *data;
        int size;
};

// Template implementation =====================================================

// ISimpleVectorOf =============================================================

// ----------------------------------------------------------------------- C & D

template <class T>
inline ISimpleVectorOf<T>::ISimpleVectorOf()
{
        size = 0;
        data = NULL;
}

template <class T>
inline ISimpleVectorOf<T>::ISimpleVectorOf( int _size, const T *_data )
{
        if (_size > 0) {
                size = _size;
                data = new T [size];
                if (_data) ::memcpy( data, _data, sizeof(T) * _size );
        }
        else {
                size = 0;
                data = NULL;
        }
}

template <class T>
inline ISimpleVectorOf<T>::ISimpleVectorOf( const ISimpleVectorOf<T> &_vector )
{
        if (_vector.size > 0) {
                size = _vector.size;
                data = new T [size];
                ::memcpy( data, _vector.data, sizeof(T) * size );
        }
        else {
                size = 0;
                data = NULL;
        }
}

template <class T>
inline ISimpleVectorOf<T>::~ISimpleVectorOf()
{
        if (data) delete [] data;
}

// ------------------------------------------------------------------- Operators

template <class T>
inline T & ISimpleVectorOf<T>::operator [] ( int idx )
{
        assert( idx>=0 && idx<size );
        return data[idx];
}

template <class T>
inline const T & ISimpleVectorOf<T>::operator [] ( int idx ) const
{
        assert( idx>=0 && idx<size );
        return data[idx];
}

template <class T>
inline ISimpleVectorOf<T> & ISimpleVectorOf<T>::operator = (
        const ISimpleVectorOf<T> &_vector )
{
        if (size!=_vector.size && data)
                delete [] data;
        if (_vector.size > 0) {
                size = _vector.size;
                data = new T [size];
                ::memcpy( data, _vector.data, sizeof(T) * size );
        }
        else {
                size = 0;
                data = NULL;
        }
        return *this;
}

// --------------------------------------------------------------------- Methods

template <class T>
inline int ISimpleVectorOf<T>::SetSize( int _size, TDataGravity gravity )
{
        if (size != _size)
                if (gravity != dgNoGravity) {
                        T *newdata = (_size>0) ? new T [_size] : NULL;
                        if (newdata!=NULL && data!=NULL) {
                                T *src = data, *dst = newdata;
                                if (gravity == dgStack) {
                                        if (size > _size)
                                                src += size - _size;
                                        else
                                                dst += _size - size;
                                }
                                ::memcpy( dst, src, sizeof (T)*  ((_size<size) ? _size : size ));
                        }
                        if (data) delete [] data;
                        size = _size;
                        data = newdata;
                }
                else {
                        if (data) delete [] data;
                        size = _size;
                        data = (size > 0) ? new T [size] : NULL;
                }
        return size;
}

template <class T>
inline T & ISimpleVectorOf<T>::Data( int idx )
{
        assert( idx>=0 && idx<size );
        return data[idx];
}

template <class T>
inline const T & ISimpleVectorOf<T>::Data( int idx ) const
{
        assert( idx>=0 && idx<size );
        return data[idx];
}

//==============================================================================
// template class ISimpleArrayOf<T>
// Description: template class for basic array functionality
//==============================================================================

template <class T>
class ISimpleArrayOf : private ISimpleVectorOf<T>
{
// ----------------------------------------------------------------------- C & D
public:
        inline ISimpleArrayOf( int = 0, int = 16, int = 0, const T * = NULL );
        inline ISimpleArrayOf( const ISimpleArrayOf<T> & );

// ------------------------------------------------------------------- Operators
public:
        inline ISimpleArrayOf<T> & operator =( const ISimpleArrayOf<T> & );

        inline T & operator [] ( int );
        inline const T & operator [] ( int ) const;

// ------------------------------------------------------------------- Accessing
public:
        T * Data() { return data; }
        const T * Data() const { return data; }

// ------------------------------------------------------------------ Publishing
public:
        ISimpleVectorOf<T>::Size;

// --------------------------------------------------------------------- Methods
public:
        inline int SetSize( int );
        int Count() const { return count; }
        void Clear() { count = 0; }

        int Delta() const { return delta; }
        inline int SetDelta( int );

        inline T * New();
        inline T * New( int );

        inline int Add( const T & );
        inline int Add( const T *, int );
        inline int Add( const ISimpleArrayOf<T> & );
        inline int Insert( int, const T & );
        inline int Insert( int, const T *, int );
        inline int Insert( int, const ISimpleArrayOf<T> & );
        inline int Remove( int, int = 1 );

        int Fit() { return SetSize( count, dgNormal ); }

        int IndexOf( const T *value ) const
        { return (value!=NULL && value>=data && value<=data+count)
                        ? value-data : -1; }

// ------------------------------------------------------------------ Attributes
protected:
        int count, delta;

        int SetSize( int _size, TDataGravity dg )
                { return ISimpleVectorOf<T>::SetSize( _size, dg ); }
};
// Template implementation =====================================================

// ISimpleArrayOf ==============================================================

// ----------------------------------------------------------------------- C & D
template <class T>
inline ISimpleArrayOf<T>::ISimpleArrayOf(
                int _size, int _delta, int _count, const T *_data ) :
        ISimpleVectorOf<T>( _size )
{
        delta = _delta > 0 ? _delta : 0;
        if (_count>0 && _count<=_size) {
                count = _count;
                if (_data != NULL)
                        ::memcpy( data, _data, sizeof (T) * count );
        }
        else
                count = 0;
}

template <class T>
inline ISimpleArrayOf<T>::ISimpleArrayOf( const ISimpleArrayOf<T> &array ) :
        ISimpleVectorOf<T>( array )
{
        count = array.count;
        delta = array.delta;
}

// ------------------------------------------------------------------- Operators
template <class T>
inline ISimpleArrayOf<T> & ISimpleArrayOf<T>::operator =(
        const ISimpleArrayOf<T> &array )
{
        if (size < array.count)
                SetSize( array.count, dgNoGravity );
        count = array.count;
        delta = array.delta;
        if (count > 0)
                ::memcpy( data, array.data, sizeof (T) * count );
        return *this;
}

template <class T>
inline T & ISimpleArrayOf<T>::operator [] ( int idx )
{
        assert(idx>=0 && idx<count );
        return data[idx];
}

template <class T>
inline const T & ISimpleArrayOf<T>::operator [] ( int idx ) const
{
        assert(idx>=0 && idx<count );
        return data[idx];
}

// --------------------------------------------------------------------- Methods
template <class T>
inline int ISimpleArrayOf<T>::SetSize( int _size )
{
        int result = SetSize( _size, dgNormal );
        count = _size;
        return result;
}

template <class T>
inline int ISimpleArrayOf<T>::SetDelta( int _delta )
{
        delta = _delta>0 ? delta : 0;
        return delta;
}

template <class T>
inline T * ISimpleArrayOf<T>::New()
{
        return (count == size && (delta == 0 ||
                        !SetSize( size + delta, dgNormal )))
                ? NULL : (data + count++);
}

template <class T>
inline T * ISimpleArrayOf<T>::New( int pos )
{
        if (pos<0 || pos>count || (count == size && (delta == 0 ||
                        !SetSize( size + delta, dgNormal ))))
                return NULL;
        else {
                int dif = count++ - pos;
                if (dif > 0)
                        ::memmove( data+pos+1, data+pos, sizeof (T) * dif );
                return data + pos;
        }
}

template <class T>
inline int ISimpleArrayOf<T>::Add( const T &value )
{
        if (count == size && (delta == 0 ||
                        !SetSize( size + delta, dgNormal )))
                return -1;
        else {
                int pos = count++;
                data[ pos ] = value;
                return pos;
        }
}

template <class T>
inline int ISimpleArrayOf<T>::Add( const T *values, int n )
{
        if (n<=0 || (count+n-1 >= size && (delta == 0 ||
                        !SetSize( count + n, dgNormal ))))
                return -1;
        else {
                int pos = count;
                count += n;
                ::memcpy( data + pos, values, sizeof(T) * n );
                return pos;
        }
}

template <class T>
inline int ISimpleArrayOf<T>::Add( const ISimpleArrayOf<T> &array )
{
        return array.count>0 ? Add( array.data, array.count ) : -1;
}

template <class T>
inline int ISimpleArrayOf<T>::Insert( int pos, const T &value )
{
        if (pos<0 || pos>count || (count == size && (delta == 0 ||
                        !SetSize( size + delta, dgNormal ))))
                return -1;
        else {
                int dif = count++ - pos;
                if (dif > 0)
                        ::memmove( data+pos+1, data+pos, sizeof (T) * dif );
                data[ pos ] = value;
                return pos;
        }
}

template <class T>
inline int ISimpleArrayOf<T>::Insert( int pos, const T *values, int n )
{
        if (n<=0 || (count+n+1 >= size && (delta == 0 ||
                        !SetSize( count + n, dgNormal ))))
                return -1;
        else {
                int dif = count - pos;
                count += n;
                if (dif > 0)
                        ::memmove( data+pos+n, data+pos, sizeof (T) * dif );
                ::memcpy( data+pos, values, sizeof (T) * n );
                return pos;
        }
}

template <class T>
inline int ISimpleArrayOf<T>::Insert( int pos, const ISimpleArrayOf<T> &array )
{
        return array.count>0 ? Insert( pos, array.data, array.count ) : -1;
}

template <class T>
inline int ISimpleArrayOf<T>::Remove( int pos, int n )
{
        if (pos<0 || pos>=count || n<=0 || (pos+n)>count)
                return -1;
        else {
                int dif = (count -= n) - pos;
                if (dif > 0)
                        ::memmove( data+pos, data+pos+n, sizeof (T) * dif );
                return pos;
        }
}


//==============================================================================
// template class IObjectArrayOf<T>
// Description: template class for object array functionality
//==============================================================================

template <class T>
class IObjectArrayOf : private ISimpleArrayOf<T *>
{

// ----------------------------------------------------------------------- C & D
public:
        typedef T * const * TObjs;

        inline IObjectArrayOf( bool = true, int = 0, int = 16 );
        inline ~IObjectArrayOf();

// ------------------------------------------------------------------- Operators
public:
        inline T * operator [] ( int );
        inline const T * operator [] ( int ) const;

// -------------------------------------------------------------- Object Methods
public:
        T * const * Objects() { return ISimpleArrayOf<T *>::Data(); }
        const T * const * Objects() const { return ISimpleArrayOf<T *>::Data(); }

// ------------------------------------------------------------------ Publishing
public:
        ISimpleArrayOf<T *>::Size;
        ISimpleArrayOf<T *>::Count;

        ISimpleArrayOf<T *>::Delta;
        ISimpleArrayOf<T *>::SetDelta;

// --------------------------------------------------------------------- Methods
public:
        virtual void Clear();
        
        inline int Add( T * );
        inline int Add( IObjectArrayOf<T> & );
        inline int Insert( int, T * );
        inline int Insert( int, IObjectArrayOf<T> & );
        inline int Remove( int, int = 1 );

        bool IsOwner() const { return owner; }
        inline bool SetOwner( bool _owner );

public:
        T * const * Data() const { return ISimpleArrayOf<T *>::Data(); }

protected:
        T ** Data() { return ISimpleArrayOf<T *>::Data(); }
        void FreeObjects( int, int );

// ------------------------------------------------------------------ Attributes
protected:
        bool owner;
};


// algorithms ==================================================================

// ----------------------------------------------------------- object allocation

template <class T>
IObjectArrayOf<T> & Init( IObjectArrayOf<T> &array, int n )
{
        while (n-- > 0) array.Add( new T );
        return array;
}

template <class T>
IObjectArrayOf<T> & Init( IObjectArrayOf<T> &array, int pos, int n )
{
        if (pos>=0 && pos<=array.Count())
                while (n-- > 0) array.Insert( pos++, new T );
        return array;
}

// Template implementation =====================================================

// IObjectArrayOf ==============================================================

// ----------------------------------------------------------------------- C & D
template <class T>
inline IObjectArrayOf<T>::IObjectArrayOf( bool _owner, int _size, int _delta ) :
        ISimpleArrayOf<T*>( _size, _delta )
{
        owner = _owner;
}

template <class T>
inline IObjectArrayOf<T>::~IObjectArrayOf()
{
        Clear();
}

// ------------------------------------------------------------------- Operators

template <class T>
inline T * IObjectArrayOf<T>::operator [] ( int idx )
{
        assert( idx>=0 && idx<count && Data()[idx] );
        return Data()[idx];
}

template <class T>
inline const T * IObjectArrayOf<T>::operator [] ( int idx ) const
{
        assert( idx>=0 && idx<count && Data()[idx] );
        return Data()[idx];
}

// --------------------------------------------------------------------- Methods
template <class T>
inline void IObjectArrayOf<T>::Clear()
{
        if (owner)
                FreeObjects( 0, count );
        count = 0;
}

template <class T>
inline int IObjectArrayOf<T>::Add( T *object )
{
        return object!=NULL ? ISimpleArrayOf<T*>::Add( object ) : -1;
}

template <class T>
inline int IObjectArrayOf<T>::Add( IObjectArrayOf<T> &array )
{
        assert( !owner || !array.owner );
        return ISimpleArrayOf<T*>::Add( array );
}

template <class T>
inline int IObjectArrayOf<T>::Insert( int pos, T *object )
{
        return object!=NULL ? ISimpleArrayOf<T*>::Insert( pos, object ) : -1;
}

template <class T>
inline int IObjectArrayOf<T>::Insert( int pos, IObjectArrayOf<T> &array )
{
        return ISimpleArrayOf<T*>::Insert( pos, array );
}

template <class T>
inline int IObjectArrayOf<T>::Remove( int pos, int n )
{
        if (pos<0 || pos>=count || n<=0 || (pos+n)>count)
                return -1;
        else {
                if (owner) FreeObjects( pos, n );
                return ISimpleArrayOf<T*>::Remove( pos, n );
        }
}

template <class T>
inline bool IObjectArrayOf<T>::SetOwner( bool _owner )
{
        bool old = owner;
        owner = _owner;
        return old;
}

template <class T>
void IObjectArrayOf<T>::FreeObjects( int pos, int n )
{
        T **cell = Data() + pos;
        while (n--) {
                delete *cell;
                *cell++ = NULL;
        }
}


} // csfl namespace

#endif // __CSFL_SYS_CORE_OARRAY_H__

 

CFD Project | Documents | Downloads | Contact us | Use Terms
© SINMEC/EMC/UFSC, 2001.	All rights reserved.	Last Update: Jan. 18, 2002	Webmaster