CircularBuffer Class Reference

#include <CircularBuffer.h>

Public Member Functions
	CircularBuffer (server_rec *Server, unsigned int BufferSize, unsigned int ElementSize)
	Construtor da classe, usado para criar o objeto.
	~CircularBuffer ()
bool	GetElement (char *Data)
bool	TotalElements (unsigned int *TotalElements)
	Funcao para retornar o numero de elementos no buffer circular (usada pelo novo comando upload, para evitar bloquear quando nao existem mais blocos a serem recebidos).
bool	SetElement (char *Data)
bool	CleanBuffer ()
bool	ReinitializeBuffer ()
	Funcao para inicializar as variaveis do buffer.
bool	CancelGetElement ()
int	GetError ()
Private Attributes
server_rec *	m_Server
bool	m_Initialized
bool	m_CancelGetOperation
bool	m_CancelSetOperation
int	m_SystemStatus
int	m_BufferSize
int	m_ElementSize
int	m_NextElement
int	m_TotalElements
char **	m_Buffer
pthread_mutex_t	m_Mutex
pthread_cond_t	m_CondFull
pthread_cond_t	m_CondEmpty

---

Detailed Description

Definition at line 31 of file CircularBuffer.h.

---

Constructor & Destructor Documentation

CircularBuffer::CircularBuffer	(	server_rec *	Server,
		unsigned int	BufferSize,
		unsigned int	ElementSize
	)

Construtor da classe, usado para criar o objeto.

Parameters:

	Server	ponteiro para a estrutura com as informacoes do servidor (atualmente somente a usamos para imprimir depuracoes).
	BufferSize	numero de elementos do buffer.
	ElementSize	tamanho em bytes de cada elemento.

Definition at line 30 of file CircularBuffer.cpp.

{
    int i, j;
    int status;
    
    // Inicializa as variaveis da classe
    m_Server = Server;
    m_BufferSize = BufferSize;
    m_ElementSize = ElementSize;
    m_SystemStatus = 0;
    m_NextElement = 0;
    m_TotalElements = 0;
    m_Initialized = false;
    m_CancelGetOperation = false;
    m_CancelSetOperation = false;
    
    // Aloca o buffer de acordo com o tamanho passado, com cada elemento tendo
    // ElementSize bytes.
    
    m_Buffer = new char*[ m_BufferSize ];
    if( m_Buffer == NULL )
    {
        m_SystemStatus = ENOMEM;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error allocation m_Buffer: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus )  );
        #endif             

        return;  
    }
    
    for( i = 0; i < m_BufferSize; i++ )
    {
        m_Buffer[ i ] = new char[ m_ElementSize ];
        if( m_Buffer[ i ] == NULL )
        {

            m_SystemStatus = ENOMEM;
          
            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                          "Error allocation m_Buffer: %u (%s)", m_SystemStatus,
                          strerror( m_SystemStatus )  );
            #endif               

            // Remove o que ja foi alocado
            for( j = 0; j < i; j++ )
                delete[] m_Buffer[ j ];
            
            delete[] m_Buffer;

            m_Buffer = NULL;
            return;    
        }
    }

    // Inicializa os mutexes usados pela classe e a variavel de condicao usada
    // pela classe.
    status = pthread_mutex_init( &m_Mutex, NULL );
    if( status <  0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error initializing m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif               

        return;
    }
    
    status = pthread_cond_init( &m_CondFull, NULL );
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error initializing m_CondFull: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif               

        return;
    }

    status = pthread_cond_init( &m_CondEmpty, NULL );
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error initializing m_CondEmpty: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif               

        return;
    }

    m_Initialized = true;
}

CircularBuffer::~CircularBuffer

(

)

Definition at line 137 of file CircularBuffer.cpp.

{
    int i;
    int status;

    // Limpa o buffer (desbloqueando threads que podem estar bloqueadas).
    CleanBuffer();
    
    // Remove o buffer
    if( m_Buffer != NULL )
    {
        // Remove o que ja foi alocado
        for( i = 0; i < m_BufferSize; i++ )
            delete[] m_Buffer[ i ];
            
        delete[] m_Buffer;

        m_Buffer = NULL;
    }
    
    // Remove os mutexes e variaveis de condicao.
    status = pthread_mutex_destroy( &m_Mutex );
    if( status < 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error destroying m_Mutex: %u (%s)", status,
                      strerror( status ) );
        #endif               
    } 
    
    status = pthread_cond_destroy( &m_CondFull );
    if( status < 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error destroying m_CondFull: %u (%s)", status,
                      strerror( status ) );
        #endif               
    } 

    status = pthread_cond_destroy( &m_CondEmpty );
    if( status < 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error destroying m_CondEmpty: %u (%s)", status,
                      strerror( status ) );
        #endif               
    } 
}

---

Member Function Documentation

bool CircularBuffer::CancelGetElement

(

)

Definition at line 755 of file CircularBuffer.cpp.

{
    int status;
    bool Result;

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                  "Executing CancelGetElement" );
    #endif

    // Inicializa o retorno da funcao.
    Result = true;

    if( !m_Initialized )
    {

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Circular buffer not initialized" );
        #endif               

       return false;
    }

    // Obtem o acesso exclusivo ao buffer.
    status = pthread_mutex_lock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error locking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif

        return false;
    }

    // Cancela a espera pelo buffer ter algum elemento.
    // Cancela a thread pendente em GetElement.
    m_CancelGetOperation = true;

    status = pthread_cond_signal( &m_CondEmpty );
    if( status < 0 )
    {
        m_SystemStatus = status;

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error signalling m_CondEmpty: %u (%s)",
                      m_SystemStatus, strerror( m_SystemStatus ) );
        #endif

        Result = false;
    }

    // Libera o acesso exclusivo ao buffer.
    status = pthread_mutex_unlock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error unlocking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus )  );
        #endif               
        
        return false;
    }

    return( Result );
}

bool CircularBuffer::CleanBuffer

(

)

Definition at line 618 of file CircularBuffer.cpp.

{ 
    int status;

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Executing CleanBuffer" );
    #endif               

    if( !m_Initialized )
    {

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Circular buffer not initialized (3)" );
        #endif               

       return false;
    }

    // Obtem o acesso exclusivo ao buffer.
    status = pthread_mutex_lock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error locking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif               
        
        return false;
    }

    // Cancela a espera pelo buffer deixar de ficar cheio, se isso for
    // necessario (ou seja, se m_TotalElementsfor igual a m_BufferSize).
    if( m_TotalElements == m_BufferSize )
    {
        // Indica a thread que a espera foi cancelada, ou que ela nao precisa
        // mais esperar.
        m_CancelSetOperation = true;

        status = pthread_cond_signal( &m_CondFull );
        if( status < 0 )
        {
            m_SystemStatus = status;

            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                          "Error signalling m_CondFull: %u (%s)",
                          m_SystemStatus, strerror( m_SystemStatus ) );
            #endif

            // Libera o acesso exclusivo ao buffer.
            status = pthread_mutex_unlock( &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;

                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error unlocking m_Mutex: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus )  );
                #endif

                return false;
            }

            return false;
        }
    }

    // Cancela a espera pelo buffer ter algum elemento, se isso for necessario
    // (ou seja, se m_TotalElementsfor igual a 0).
    if( m_TotalElements == 0 )
    {
        // Indica a thread que a espera foi cancelada, ou que ela nao precisa
        // mais esperar.
        m_CancelGetOperation = true;

        status = pthread_cond_signal( &m_CondEmpty );
        if( status < 0 )
        {
            m_SystemStatus = status;

            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                          "Error signalling m_CondEmpty: %u (%s)",
                          m_SystemStatus, strerror( m_SystemStatus ) );
            #endif

            // Libera o acesso exclusivo ao buffer.
            status = pthread_mutex_unlock( &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;

                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error unlocking m_Mutex: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus )  );
                #endif

                return false;
            }

            return false;
        }
    }

    // Limpa as variaveis do buffer.
    m_TotalElements = 0;
    m_NextElement = 0;
    
    // Libera o acesso exclusivo ao buffer.
    status = pthread_mutex_unlock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error unlocking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus )  );
        #endif               
        
        return false;
    }

    // Limpa o codigo de erro.
    m_SystemStatus = 0;

    return true;
} 

bool CircularBuffer::GetElement

(

char *

Data

)

Definition at line 190 of file CircularBuffer.cpp.

{
    int status;

    // Verifica se a classe foi inicializada.
    if( !m_Initialized )
    {

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Circular buffer not initialized (1)" );
        #endif               

       return false;
    }

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                  "Trying to remove a element in buffer" );
    #endif               
    
    // Obtem o acesso exclusivo ao buffer.
    status = pthread_mutex_lock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error locking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif               
        
        return false;
    }

    // Verifica se o buffer esta vazio e, caso esteja, bloqueia a thread que
    // chamou a funcao ate que SetElement seja chamada.
    if( m_TotalElements == 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Buffer is empty. Waiting for a element" );
        #endif               

        if( !m_CancelGetOperation )
        {
            status = pthread_cond_wait( &m_CondEmpty, &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;

                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error waiting in m_CondEmpty: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus ) );
                #endif

                status = pthread_mutex_unlock( &m_Mutex );
                if( status < 0 )
                {
                    m_SystemStatus = status;

                    #ifdef RIO_DEBUG2
                    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                  "Error unlocking m_Mutex: %u (%s)",
                                  m_SystemStatus, strerror( m_SystemStatus ) );
                    #endif
        
                    return false;
                }

                return false;
            }
        }

        // Verifica se o numero de elementos e 0. Se isso ocorreu, a operacao
        // foi cancelada sem colocarmos elementos no buffer, e deveremos
        // Inicializamos a variavel de cancelamento para false, pois ja passamos
        // pela variavel de condicao.
        m_CancelGetOperation = false;

        // retornar um codigo de erro neste caso.
        if( m_TotalElements == 0 )
        {
            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                          "GetElement Operation was cancelled" );
            #endif
            
            status = pthread_mutex_unlock( &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;
        
                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error unlocking m_Mutex: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus ) );
                #endif               
        
                return false;
            }

            return false;
        }
    }

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                  "Removing element with %u bytes of %u (%u/%u elements)",
                  m_ElementSize, m_NextElement, m_TotalElements, m_BufferSize );
    #endif               
    
    // Copia os dados do elemento atual para Data.
    memcpy( Data, m_Buffer[ m_NextElement ], m_ElementSize );
    
    // Atualiza o ponteiro para o proximo elemento.
    m_NextElement = ( m_NextElement + 1 ) % m_BufferSize;

    // Decrementa o contador com o numero de elementos disponiveis
    m_TotalElements--;
    
    // Verifica se precisamos enviar um sinal para a variavel de condicao 
    // m_CondFull, caso o numero de elementos fosse igual a m_BufferSize, pois
    // alguma thread pode, neste caso, estar bloqueada em SetElement.
    if( m_TotalElements == ( m_BufferSize - 1 ) )
    { 
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Buffer was full. Sending a signal to m_CondFull" );
        #endif               

        status = pthread_cond_signal( &m_CondFull );
        if( status < 0 )
        {
            m_SystemStatus = status;
          
            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                          "Error signalling m_CondFull: %u (%s)",
                          m_SystemStatus, strerror( m_SystemStatus ) );
            #endif               
            
            status = pthread_mutex_unlock( &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;
        
                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error unlocking m_Mutex: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus ) );
                #endif               
        
                return false;
            }

            return false;
        }
    }
    
    // Libera o acesso exclusivo ao buffer.
    status = pthread_mutex_unlock( &m_Mutex ) ;
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error unlocking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus )  );
        #endif               
        
        return false;
    }
    
    return true;
}

int CircularBuffer::GetError

(

)

Definition at line 893 of file CircularBuffer.cpp.

{
    return m_SystemStatus;
}

bool CircularBuffer::ReinitializeBuffer

(

)

Funcao para inicializar as variaveis do buffer.

Ela e usada quando o buffer e usado mais de uma vez.

Definition at line 832 of file CircularBuffer.cpp.

{
    int status;

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                  "Executing ReinitializeBuffer" );
    #endif

    if( !m_Initialized )
    {

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Circular buffer not initialized" );
        #endif

       return false;
    }

    // Obtem o acesso exclusivo ao buffer.
    status = pthread_mutex_lock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error locking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif

        return false;
    }

    m_SystemStatus = 0;
    m_NextElement = 0;
    m_TotalElements = 0;
    m_CancelGetOperation = false;
    m_CancelSetOperation = false;

    // Libera o acesso exclusivo ao buffer.
    status = pthread_mutex_unlock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error unlocking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus )  );
        #endif

        return false;
    }

    return true;
}

bool CircularBuffer::SetElement

(

char *

Data

)

Definition at line 435 of file CircularBuffer.cpp.

{
    unsigned int FreeElement;
    int status;
    
    if( !m_Initialized )
    {

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Circular buffer not initialized (2)" );
        #endif               

       return false;
    }

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                  "Trying to insert a element in buffer" );
    #endif               

    status = pthread_mutex_lock( &m_Mutex );
    // Obtem o acesso exclusivo ao buffer.
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error locking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif               
        
        return false;
    }
    
    // Verifica se o buffer esta chei e, caso esteja, bloqueia a thread que
    // chamou a funcao ate que GetElement seja chamada.
    if( m_TotalElements == m_BufferSize )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Buffer is full. Waiting for a empty buffer entry" );
        #endif               

        if( !m_CancelSetOperation )
        {
            status = pthread_cond_wait( &m_CondFull, &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;

                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error waiting in m_CondFull: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus ) );
                #endif

                status = pthread_mutex_unlock( &m_Mutex );
                if( status < 0 )
                {
                    m_SystemStatus = status;

                    #ifdef RIO_DEBUG2
                    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                  "Error unlocking m_Mutex: %u (%s)",
                                  m_SystemStatus, strerror( m_SystemStatus ) );
                    #endif

                    return false;
                }

                return false;
            }
        }

        // Verifica se o buffer esta cheio. Se isso ocorreu, a operacao foi
        // cancelada sem removermos elementos no buffer. Inicializamos a
        // variavel de cancelamento para false, pois ja passamos pela variavel
        // de condicao.
        m_CancelSetOperation = false;

        // Verifica se a operacao foi cancelada
        if( m_TotalElements == m_BufferSize )
        {
            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                          "SetElement Operation was cancelled" );
            #endif               

            status = pthread_mutex_unlock( &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;

                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error unlocking m_Mutex: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus ) );
                #endif

                return false;
            }

            return false;
        }
    }
    
    // Descobre a proxima entrada livre do buffer (como o buffer e circular, 
    // esta posicao sera o valor obtido ao aplicarmos o modulo sobre a soma
    // m_NextElement + m_TotalElements).
    FreeElement = ( m_NextElement + m_TotalElements ) % m_BufferSize;

    // Copia os dados do elemento atual para Data.
    memcpy( m_Buffer[ FreeElement ], Data, m_ElementSize );

    // Incrementa o contador com o numero de elementos disponiveis
    m_TotalElements++;
    
    // Verifica se precisamos enviar um sinal para a variavel de condicao 
    // m_CondEmpty, caso o buffer estivesse vazio, pois alguma thread pode, 
    // neste caso, estar bloqueada em GetElement.
    if( m_TotalElements == 1 )
    { 
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Buffer was empty. Sending a signal to m_CondEmpty" );
        #endif               

        status = pthread_cond_signal( &m_CondEmpty );
        if( status < 0 )
        {
            m_SystemStatus = status;
          
            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                          "Error signalling m_CondEmpty: %u (%s)",
                          m_SystemStatus, strerror( m_SystemStatus ) );
            #endif               
            
            status = pthread_mutex_unlock( &m_Mutex );
            if( status < 0 )
            {
                m_SystemStatus = status;
        
                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                              "Error unlocking m_Mutex: %u (%s)",
                              m_SystemStatus, strerror( m_SystemStatus ) );
                #endif               
        
                return false;
            }

            return false;
        }
    }
    
    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                  "Inserting a element with %u bytes in %u (%u/%u elements)",
                  m_ElementSize, FreeElement, m_TotalElements, m_BufferSize );
    #endif               

    // Libera o acesso exclusivo ao buffer.
    status = pthread_mutex_unlock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;
        
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error unlocking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus )  );
        #endif               
        
        return false;
    }

    return true;
}

bool CircularBuffer::TotalElements

(

unsigned int *

TotalElements

)

Funcao para retornar o numero de elementos no buffer circular (usada pelo novo comando upload, para evitar bloquear quando nao existem mais blocos a serem recebidos).

Parameters:

TotalElements

ponteiro para um valor inteiro, que sera mudado para o numero de blocks no buffer circular.

Returns:

true se existem elementos no buffer circular e false em caso contrario.

Definition at line 373 of file CircularBuffer.cpp.

{
    int status;

    // Inicializa o ponteiro passado para false, caso erros ocorram ao chamar a
    // funcao.
    *TotalElements = 0;

    // Verifica se a classe foi inicializada.
    if( !m_Initialized )
    {

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Circular buffer not initialized (4)" );
        #endif

       return false;
    }

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                  "Trying to remove a element in buffer" );
    #endif

    // Obtem o acesso exclusivo ao buffer.
    status = pthread_mutex_lock( &m_Mutex );
    if( status < 0 )
    {
        m_SystemStatus = status;

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error locking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus ) );
        #endif

        return false;
    }

    // Salva o numero total de elementos.
    *TotalElements = m_TotalElements;

    // Libera o acesso exclusivo ao buffer.
    status = pthread_mutex_unlock( &m_Mutex ) ;
    if( status < 0 )
    {
        m_SystemStatus = status;

        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Error unlocking m_Mutex: %u (%s)", m_SystemStatus,
                      strerror( m_SystemStatus )  );
        #endif

        return false;
    }

    return true;
}

---

Field Documentation

char** CircularBuffer::m_Buffer [private]

Definition at line 61 of file CircularBuffer.h.

int CircularBuffer::m_BufferSize [private]

Definition at line 53 of file CircularBuffer.h.

bool CircularBuffer::m_CancelGetOperation [private]

Definition at line 43 of file CircularBuffer.h.

bool CircularBuffer::m_CancelSetOperation [private]

Definition at line 48 of file CircularBuffer.h.

pthread_cond_t CircularBuffer::m_CondEmpty [private]

Definition at line 70 of file CircularBuffer.h.

pthread_cond_t CircularBuffer::m_CondFull [private]

Definition at line 66 of file CircularBuffer.h.

int CircularBuffer::m_ElementSize [private]

Definition at line 55 of file CircularBuffer.h.

bool CircularBuffer::m_Initialized [private]

Definition at line 39 of file CircularBuffer.h.

pthread_mutex_t CircularBuffer::m_Mutex [private]

Definition at line 63 of file CircularBuffer.h.

int CircularBuffer::m_NextElement [private]

Definition at line 57 of file CircularBuffer.h.

server_rec* CircularBuffer::m_Server [private]

Definition at line 36 of file CircularBuffer.h.

int CircularBuffer::m_SystemStatus [private]

Definition at line 51 of file CircularBuffer.h.

int CircularBuffer::m_TotalElements [private]

Definition at line 59 of file CircularBuffer.h.

---

The documentation for this class was generated from the following files:

• CircularBuffer.h
• CircularBuffer.cpp