BCondInt.h

Go to the documentation of this file.

/*******************************************************************************
 *  BCondInt.h  BCondInt Class
 *  T.Barnaby,  BEAM Ltd,   10/12/02
 *  Copyright (c) 2012 All Right Reserved, Beam Ltd, http://www.beam.ltd.uk
 *******************************************************************************
 *
 * For license see LICENSE.txt at the root of the beamlib source tree.
 */
#ifndef BCONDINT_H
#define BCONDINT_H  1
 
#include <BTypes.h>
#include <pthread.h>
 
class BCondInt {
public:
            BCondInt();
            ~BCondInt();
    
    void        setValue(BInt value);           
    BInt        value() const;              
 
    BInt        increment(BInt v = 1);          
    BInt        decrement(BInt v = 1);          
 
    Bool        waitMoreThanOrEqual(BInt v, Bool decrement = 0, BTimeout timeoutUs = BTimeoutForever);  
    Bool        waitLessThanOrEqual(BInt v, Bool increment = 0, BTimeout timeoutUs = BTimeoutForever);  
    Bool        waitLessThan(BInt v, BTimeout timeoutUs = BTimeoutForever);                 
 
    void        operator+=(int v);          
    void        operator-=(int v);          
    void        operator++(int);            
    void        operator--(int);            
 
private:
    pthread_mutex_t omutex;
    pthread_cond_t  ocond;
    BInt        ovalue;
};
 
inline void BCondInt::operator+=(BInt v){
    increment(v);
}
 
inline void BCondInt::operator-=(BInt v){
    decrement(v);
}
 
inline void BCondInt::operator++(int){
    increment(1);
}
 
inline void BCondInt::operator--(int){
    decrement(1);
}
 
 
class BCondValue {
public:
            BCondValue();
            ~BCondValue();
    
    void        setValue(int value);            
    int     value();                
 
    int     increment(int v = 1);           
    int     decrement(int v = 1);           
 
    int     waitMoreThanOrEqual(int v, int decrement = 0, int timeOutUs = 0);   
    int     waitLessThanOrEqual(int v, int increment = 0, int timeOutUs = 0);   
    int     waitLessThan(int v, int timeOutUs = 0);                 
 
    void        operator+=(int v);          
    void        operator-=(int v);          
    void        operator++(int);            
    void        operator--(int);            
private:
    pthread_mutex_t omutex;
    pthread_cond_t  ocond;
    int     ovalue;
};
 
inline void BCondValue::operator+=(int v){
    increment(v);
}
 
inline void BCondValue::operator-=(int v){
    decrement(v);
}
 
inline void BCondValue::operator++(int){
    increment(1);
}
 
inline void BCondValue::operator--(int){
    decrement(1);
}
 
class BCondBool {
public:
            BCondBool();
            ~BCondBool();
    
    int     set();                  
    int     clear();                
    int     value();                
    int     wait();                 
    int     timedWait(int timeOutUs);       
    
            operator int(){ return value(); }
private:
    pthread_mutex_t omutex;
    pthread_cond_t  ocond;
    int     ovalue;
};
 
class BCondWrap {
public:
            BCondWrap();
            ~BCondWrap();
    
    void        setValue(uint32_t value);           
    uint32_t    value();                    
 
    uint32_t    increment(uint32_t v = 1);          
    uint32_t    decrement(uint32_t v = 1);          
 
    int     waitMoreThanOrEqual(uint32_t v, uint32_t decrement = 0, uint32_t timeOutUs = 0);    
    int     waitLessThanOrEqual(uint32_t v, uint32_t increment = 0, uint32_t timeOutUs = 0);    
    int     waitLessThan(uint32_t v, uint32_t timeOutUs = 0);               
 
    void        operator+=(int v);          
    void        operator-=(int v);          
    void        operator++(int);            
    void        operator--(int);            
private:
    int     diff(uint32_t v);
    
    pthread_mutex_t omutex;
    pthread_cond_t  ocond;
    uint32_t    ovalue;
};
 
inline void BCondWrap::operator+=(int v){
    increment(v);
}
 
inline void BCondWrap::operator-=(int v){
    decrement(v);
}
 
inline void BCondWrap::operator++(int){
    increment(1);
}
 
inline void BCondWrap::operator--(int){
    decrement(1);
}
 
class BCondResource {
public:
            BCondResource();
            ~BCondResource();
    
    int     lock(uint32_t timeOutUs = 0);       
    int     unlock();               
 
    int     start(uint32_t timeOutUs = 0);      
    int     end();                  
    
    int     locked();
    int     inUse();
private:
    pthread_mutex_t omutex;
    pthread_cond_t  ocond;
    int     olock;
    int     ouse;
};
 
#endif