ArrayBuffer.h

Go to the documentation of this file.

/*
 * $Revision: 2027 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2010-09-01 11:55:17 +0200 (Wed, 01 Sep 2010) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_ARRAY_BUFFER_H
#define OGDF_ARRAY_BUFFER_H

#include <ogdf/basic/Array.h>

namespace ogdf {


template<class E, class INDEX = int> 
class ArrayBuffer : private Array<E, INDEX> {
    INDEX num; 
public: 
    ArrayBuffer() : Array<E,INDEX>(), num(0) {}
    explicit ArrayBuffer(INDEX size) : Array<E,INDEX>(size), num(0) {}
    
    void init() { Array<E,INDEX>::init(); }
    void init(INDEX size) { Array<E,INDEX>::init(size); }

    void clear() { num = 0; }
    
    const E &top() const { OGDF_ASSERT(num>0); return Array<E,INDEX>::operator[](num-1); };
    E &top() { OGDF_ASSERT(num>0); return Array<E,INDEX>::operator[](num-1); };
    
    void push(E e) {
        if(num == Array<E,INDEX>::size())
            Array<E,INDEX>::grow(max(num,1)); // double the size
        Array<E,INDEX>::operator[](num++) = e; 
    };

    void pop() { OGDF_ASSERT(num>0); --num; };
    E popRet() { OGDF_ASSERT(num>0); return Array<E,INDEX>::operator[](--num); };
    
    bool empty() const { return !num; }

    INDEX size() const { return num; }
    
    const E &operator[](INDEX i) const {
        OGDF_ASSERT(0 <= i && i < num)
        return Array<E,INDEX>::operator[](i);
    }
    E &operator[](INDEX i) {
        OGDF_ASSERT(0 <= i && i < num)
        return Array<E,INDEX>::operator[](i);
    }   


    void compactCopy(Array<E,INDEX>& A2) const {
        OGDF_ASSERT(this != &A2);
        if(num) {
            A2.init(num);
            for(INDEX i = num; i-->0;)
                A2[i] = (*this)[i];
        } else
            A2.init(0);
    }


    void compactCpycon(Array<E,INDEX>& A2) const {
        OGDF_ASSERT(this != &A2);
        if(num) {
            INDEX tmp = Array<E,INDEX>::m_high; // thank god i'm a friend of Array
            Array<E,INDEX>::m_high = num-1; // fake smaller size
            A2.copy(*this); // copy
            Array<E,INDEX>::m_high = tmp;
        } else
            A2.init(0);
    }


    void compactMemcpy(Array<E,INDEX>& A2) const {
        OGDF_ASSERT(this != &A2);
        if(num) {
            A2.init(num);
            memcpy(A2.m_pStart,this->m_pStart,sizeof(E)*num);
        } else
            A2.init(0);
    }


    INDEX linearSearch (const E& x) const {
        INDEX i;
        for(i = num; i-->0;)
            if(x == Array<E,INDEX>::m_vpStart[i]) break;
        return i;
    }


    template<class COMPARER>
    INDEX linearSearch (const E& x, const COMPARER &comp) const {
        INDEX i;
        for(i = num; i-->0;)
            if(comp.equal(x, Array<E,INDEX>::m_vpStart[i])) break;
        return i;
    }
};

} //namespace

#endif // OGDF_ARRAY_BUFFER_H