Humble Framework for SkyOS

---

HArray.h

Go to the documentation of this file.

/****************************************************************************
**
**  $Header: /SkyOS.root/HFramework/HArray.h 3     4/17/05 12:29p Lee Neuse $
**
****************************************************************************/
#ifndef HARRAY_H
    #define HARRAY_H
/*  -----------------------------------------------------------------------
    HArray class
    ----------------------------------------------------------------------- */
template <class T>
class HArray :  public HObj,
                public  std::vector<T>
    {
    typedef HObjNoCopy      base_class;
    static StringPtr        ClassName(void) { return "HArray<T>"; }
public:
    typedef typename std::vector<T>::iterator   HArrayIterator;

/*  -----------------------------------------------------------------------
    VARIABLES
    ----------------------------------------------------------------------- */

/*  -----------------------------------------------------------------------
    CTOR/DTOR
    ----------------------------------------------------------------------- */
public:
    HArray(uint32 uSize = 0)
        {
        if (uSize)
            SetSize(uSize);
        }

    ~HArray(void)
        { 
        if (!IsNotEmpty())
            {
            DEBUG_LOG("~HArray() => %u elements still in array\n", this->size());
            this->clear(); 
            }
        }
/*  -----------------------------------------------------------------------
    METHODS
    ----------------------------------------------------------------------- */
public:
    ErrCode             
    Append(const T & tData)
        {
        ErrCode     ec = HError::NoError();
        
        try
            {
            (void) this->push_back(tData);
            }
        catch (const std::exception & e)
            {
            DEBUG_LOG("HArray::Append() => caught %s.\n", e.what());
            ec = HError::Set(ERR_STL_EXCEPTION, __FILE__, __LINE__);
            }
            
        return ec;
        }
    bool
    Contains(const T & tData) const throw ()
        { 
        return (std::find(this->begin(), this->end(), tData) != this->end()); 
        }
    uint32
    Find(const T & tData) const throw ()
        { 
#if defined(HArrayIterator)
        HArrayIterator  it;
        
        it = std::find(this->begin(), this->end(), tData);
        if (it != this->end())
            return distance(this->begin(), it); 
#else
        for (uint32 udx = 0; udx < GetSize(); ++udx)
            if (this->at(udx) == tData)
                return udx;
#endif  
        return Humble::BAD_INDEX;
        }
    ErrCode
    InsertAt(uint32 udx, const T & tData, uint32 uCount = 1)
        {
        ErrCode     ec = HError::NoError();

        if (uCount > 0 && validIndex(udx))
            {
            (void) this->insert(this->begin() + udx, uCount, tData);
            }
        else
            ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
        
        return ec;
        }
    ErrCode
    RemoveAt(uint32 udx)
        {
        ErrCode     ec = HError::NoError();

        if (validIndex(udx))
            {
            (void) this->erase( this->begin() + udx );
            }
        else
            ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
        
        return ec;
        }
/*  -----------------------------------------------------------------------
    GETTERS & SETTERS
    ----------------------------------------------------------------------- */
public:
    T                   GetAt(uint32 udx) const throw () 
                            { return this->at(udx); }
    ErrCode             SetAll(const T & tData) throw () 
                            {
                            ErrCode ec = HError::NoError();
                             
                            try
                                {
                                std::fill(this->begin(), this->end(), tData);
                                }
                            catch (const std::exception & e)
                                {
                                DEBUG_LOG("HArray::SetAll() => caught %s.\n", e.what());
                                ec = HError::Set(ERR_STL_EXCEPTION, __FILE__, __LINE__);
                                }
                            
                            return ec;
                            }
    T *                 GetPtr(uint32 udx = 0) const
                            { return validIndex(udx) ? &this[udx] : NULL; }
    uint32              GetSize(void) const
                            { return this->size(); }
    ErrCode             SetAt(uint32 udx, const T & tData) throw () 
                            { 
                            ErrCode     ec = HError::NoError();
                            
                            if (validIndex(udx))
                                this[udx] = tData;
                            else
                                ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
                            
                            return ec;
                            }
    ErrCode             SetSize(uint32 uSize)
                            {
                            ErrCode     ec = HError::NoError();
                            
                            DEBUG_LOG("HArray[%p]::SetSize() => %lu\n", this, uSize);

                            try
                                {
                                if (uSize > 0)
                                    this->resize(uSize);
                                else if (uSize == 0 && IsNotEmpty())
                                    this->clear();
                                }
                            catch (const std::exception & e)
                                {
                                DEBUG_LOG("HArray::SetSize() => caught %s.\n", e.what());
                                ec = HError::Set(ERR_STL_EXCEPTION, __FILE__, __LINE__);
                                }
                                
                            return ec;
                            }
/*  -----------------------------------------------------------------------
    INLINES
    ----------------------------------------------------------------------- */
    inline bool     IsEmpty(void) const
                            { return this->empty(); }
    inline bool     IsNotEmpty(void) const
                            { return !(this->empty()); }
    inline ErrCode      RemoveAll(void)
                            { return SetSize(0); }
protected:
    inline bool     validIndex(uint32 udx) const
                            { return (udx < this->size()); }
    };

#endif  // HARRAY_H
/****************************************************************************
**
**  $History: HArray.h $
 * 
 * *****************  Version 3  *****************
 * User: Lee Neuse    Date: 4/17/05    Time: 12:29p
 * Updated in $/SkyOS.root/HFramework
 * Development snapshot 050417
 * 
 * *****************  Version 2  *****************
 * User: Neusel       Date: 12/10/04   Time: 3:57p
 * Updated in $/SkyOS.root/pig/Humble
 * 20041210
 * 
 * *****************  Version 1  *****************
 * User: Neusel       Date: 12/08/04   Time: 5:06p
 * Created in $/SkyOS.root/pig/Humble
 * 20041208
**
**  -------------------------------------------------------------------------
**
**  End of HArray.h
**
****************************************************************************/

---