cbuffer.h

Ir a la documentación de este archivo.

#include <stdio.h>
#include <cassert>
#include "xfft.h"
#include "uti.h"
#include "xalloc.h"



class buffer2D
{
protected:
    DOUBLE** m_buffer;  
    INT m_Nelem;        
    INT m_Ndim;         
    INT m_head;         
    INT m_tail;         
    //Si m_tail == -1 es que el buffer está vacío.
    //Si m_head == (m_tail+1)%m_Nelem es que el buffer está lleno del todo

public:
    
    inline
    buffer2D ()
    : m_buffer(NULL), m_Nelem (0), m_Ndim(0), m_head (0), m_tail (-1)
    {}
    
    buffer2D (INT Nelem, INT Nfft);
    
    ~buffer2D();
    
    void
    Resize (INT Nelem, INT Nfft);
            

    inline
    const DOUBLE*
    operator[] (INT idx) const
    { return m_buffer[(m_head + idx)%m_Nelem]; }
    

    inline
    DOUBLE*
    operator[] (INT idx)
    { return m_buffer[(m_head + idx)%m_Nelem]; }
    
    inline
    void
    Push (const DOUBLE* e)
    {
        //Lo primero, avanzar el puntero de cola
        Advance();

        //Ahora copiamos
        memcpy (m_buffer[m_tail], e, m_Ndim*sizeof(DOUBLE));
    }
    
    inline
    INT
    Size() const
    { return m_Nelem; }
    
    inline
    INT
    Dim() const
    { return m_Ndim; }
    
    inline
    bool
    Empty() const
    { return m_tail == -1; }
    
    inline
    const DOUBLE*
    Head () const
    { return m_buffer[m_head]; }

    inline
    void
    Head (DOUBLE* h) const
    { memcpy(h, m_buffer[m_head], m_Ndim*sizeof(DOUBLE)); }

    inline
    const DOUBLE*
    Tail () const
    { return m_buffer[m_tail]; }

    inline
    void
    Tail (DOUBLE* t) const
    { memcpy(t, m_buffer[m_tail], m_Ndim*sizeof(DOUBLE)); }

    
protected:
    
    inline
    void
    Advance ()
    {
        if (m_tail >= 0 && m_head == (m_tail+1)%m_Nelem)
            //Buffer lleno, debemos eliminar un elemento de cabeza
            m_head = (m_head+1)%m_Nelem;

        m_tail = (m_tail+1)%m_Nelem;
    }

};



class buffer1D
{
protected:
    DOUBLE* m_buffer;   
    INT m_Nelem;        
    INT m_head;         
    INT m_tail;         
    //Si m_tail == -1 es que el buffer está vacío.
    //Si m_head == (m_tail+1)%m_Nelem es que el buffer está lleno del todo

public:
    
    inline
    buffer1D ()
    : m_buffer(NULL), m_Nelem (0), m_head (0), m_tail (-1)
    {}
    
    inline
    buffer1D (INT Nelem)
    : m_Nelem (Nelem), m_head (0), m_tail (-1)
    { m_buffer = (DOUBLE*)xmalloc (Nelem*sizeof(DOUBLE)); }

    inline
    ~buffer1D()
    { if (m_buffer) xfree(m_buffer); }

    
    void
    Resize (INT Nelem);
            

    inline
    const DOUBLE
    operator[] (INT idx) const
    { return m_buffer[(m_head + idx)%m_Nelem]; }
    

    inline
    DOUBLE
    operator[] (INT idx)
    { return m_buffer[(m_head + idx)%m_Nelem]; }
    
    inline
    void
    Push (DOUBLE e)
    {
        //Lo primero, avanzar el puntero de cola
        Advance();
        
        //Ahora copiamos
        m_buffer[m_tail] = e;
    }
    
    inline
    INT
    Size() const
    { return m_Nelem; }
    
    inline
    bool
    Empty() const
    { return m_tail == -1; }
    
    inline
    DOUBLE
    Head () const
    { return m_buffer[m_head]; }

    inline
    DOUBLE
    Tail () const
    { return m_buffer[m_tail]; }

    
protected:
    
    inline
    void
    Advance ()
    {
        if (m_tail >= 0 && m_head == (m_tail+1)%m_Nelem)
            //Buffer lleno, debemos eliminar un elemento de cabeza
            m_head = (m_head+1)%m_Nelem;
        m_tail = (m_tail+1)%m_Nelem;
    }

};

---