epics/pcas
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

changes after discussion with Jeff

Browse Source
This commit is contained in:
Marty Kraimer
2001-02-08 18:58:27 +00:00
parent 10bd2f2372
commit 5de0de0e14
3 changed files with 50 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
src/libCom/timer/epicsPeriodicTimer.h
View File

@@ -1,73 +0,0 @@
/* epicsPeriodicTimer.h */
/* Author: Jeffrey O. Hill */
/********************COPYRIGHT NOTIFICATION**********************************
This software was developed under a United States Government license
described on the COPYRIGHT_Combined file included as part
of this distribution.
****************************************************************************/
#ifndef epicsPeriodicTimerH
#define epicsPeriodicTimerH
#include "epicsTimer.h"
#ifdef __cplusplus
class epicsShareClass epicsPeriodicTimer : public epicsTimer {
public:
epicsPeriodicTimer(epicsTimerNotify &,double period,
epicsTimerQueue&);
epicsPeriodicTimer(epicsTimerNotify &,double period,
sharedPriority priority = priorityLow);
virtual ~epicsPeriodicTimer();
void setPeriod(double seconds);
void start();
void stop();
double getPeriod() const;
virtual void show(unsigned int level) const;
private:
class periodicImpl &periodicPvt;
private: //copy constructor and operator= not allowed
epicsPeriodicTimer(const epicsPeriodicTimer& rhs);
epicsPeriodicTimer&
operator=(const epicsPeriodicTimer& rhs);
};
extern "C" {
#endif /* __cplusplus */
typedef void *epicsPeriodicTimerId;
epicsShareFunc epicsPeriodicTimerId epicsShareAPI
epicsPeriodicTimerCreate(
epicsTimerQueueId queueid,double period,
epicsTimerCallback cb,void *arg);
epicsShareFunc epicsPeriodicTimerId epicsShareAPI
epicsPeriodicTimerCreateShared(
epicsTimerSharedPriority priority, double period,
epicsTimerCallback cb,void *arg);
epicsShareFunc void epicsShareAPI
epicsPeriodicTimerDestroy(epicsPeriodicTimerId id);
epicsShareFunc void epicsShareAPI
epicsPeriodicTimerSetPeriod(
epicsPeriodicTimerId id,double seconds);
epicsShareFunc void epicsShareAPI
epicsPeriodicTimerStart(epicsPeriodicTimerId id);
epicsShareFunc void epicsShareAPI
epicsPeriodicTimerStop(epicsPeriodicTimerId id);
epicsShareFunc double epicsShareAPI
epicsPeriodicTimerGetPeriod(epicsPeriodicTimerId id);
/* GetExpireTime returns (0,1) if time (is not, is) given a value*/
epicsShareFunc int epicsShareAPI
epicsPeriodicTimerGetExpireTime(
epicsPeriodicTimerId id, epicsTimeStamp *time);
epicsShareFunc void epicsShareAPI
epicsPeriodicTimerShow(epicsPeriodicTimerId id,unsigned int level);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /*epicsPeriodicTimerH*/

92
src/libCom/timer/epicsTimer.h
View File

@@ -16,74 +16,82 @@ of this distribution.
#include "epicsTime.h"
#include "epicsThread.h"
typedef enum {
epicsTimerPriorityLow,epicsTimerPriorityMedium,epicsTimerPriorityHigh
}epicsTimerSharedPriority;
#ifdef __cplusplus
class epicsTimerExpireStatus{
public:
bool again; // Is this a periodic timer? That is reschedule
double delay; //If again is true the delay until expire is called again
epicsTimerExpireStatus() : again(false), delay(0.0) {}
epicsTimerExpireStatus(bool a,double d) : again(a), delay(d) {}
};
// code using a timer must implement epicsTimerNotify
class epicsTimerNotify {
public:
virtual void expire() = 0;
virtual epicsTimerExpireStatus expire() = 0;
virtual void show(unsigned int level);
};
class epicsTimerQueue;
class epicsShareClass epicsTimerQueue {
public:
static epicsTimerQueue &createNonThreaded();
static epicsTimerQueue &createThreaded(
bool okToShare, int threadPriority = threadPriorityMin+10);
static destroy(epicsTimerQueue &);
virtual void process() = 0;
virtual epicsTime getExpireTime() const = 0;
virtual void show(unsigned int level) const = 0;
};
class epicsShareClass epicsTimer {
public:
epicsTimer(epicsTimerNotify &,epicsTimerQueue&);
epicsTimer(epicsTimerNotify &,
epicsTimerSharedPriority priority = epicsTimerPriorityLow);
virtual ~epicsTimer();
void start(epicsTime &);
void start(double delaySeconds);
virtual void cancel();
epicsTime getExpireTime() const;
double getExpireSeconds() const;
bool isExpired() const;
epicsTimerNotify &getNotify() const;
epicsTimerQueue &getQueue() const;
virtual void show(unsigned int level) const;
static epicsTimerQueue &createTimerQueue(
unsigned int threadPriority = epicsThreadPriorityMin);
static void deleteTimerQueue(epicsTimerQueue &);
protected:
class impl& timerPvt;
private: //copy constructor and operator= not allowed
epicsTimer(const epicsTimer&);
epicsTimer& operator=(const epicsTimer&);
static epicsTimer& create(epicsTimerNotify &,epicsTimerQueue&);
static destroy(epicsTimer&);
virtual void start(epicsTime &) = 0;
virtual void start(double delaySeconds) = 0;
virtual virtual void cancel() = 0;
virtual epicsTime getExpireTime() const = 0;
virtual bool isExpired() const = 0;
virtual void show(unsigned int level) const = 0;
};
extern "C" {
#endif /*__cplusplus */
typedef void *epicsTimerId;
typedef void *epicsTimerQueueId;
epicsShareFunc epicsTimerQueueId* epicsShareAPI
epicsTimerQueueCreateNonThreaded();
epicsShareFunc epicsTimerQueueId* epicsShareAPI
epicsTimerQueueCreateThreaded(unsigned int threadPriority,int okToShare);
epicsShareFunc void epicsShareAPI epicsTimerQueueDelete(epicsTimerQueueId);
epicsShareFunc void epicsShareAPI epicsTimerQueueProcess(epicsTimerQueueId);
epicsShareFunc int epicsShareAPI epicsTimerQueueGetExpireTime(
epicsTimerQueueId, epicsTimeStamp *time);
epicsShareFunc void epicsShareAPI epicsTimerQueueShow(
epicsTimerQueueId id, unsigned int level);
typedef void *epicsTimerId;
typedef void (*epicsTimerCallback)(void *);
epicsShareFunc epicsTimerId epicsShareAPI epicsTimerCreate(
epicsTimerQueueId queueid,epicsTimerCallback callback, void *arg);
epicsShareFunc epicsTimerId epicsShareAPI epicsTimerCreateShared(
epicsTimerSharedPriority priority,epicsTimerCallback callback, void *arg);
epicsShareFunc void epicsShareAPI epicsTimerDestroy(epicsTimerQueueId id);
epicsShareFunc void epicsShareAPI epicsTimerDestroy(epicsTimerId id);
epicsShareFunc void epicsShareAPI epicsTimerStartTime(
epicsTimerQueueId id,epicsTimeStamp *time);
epicsTimerId id,epicsTimeStamp *time);
epicsShareFunc void epicsShareAPI epicsTimerStartDelay(
epicsTimerQueueId id,double delaySeconds);
epicsShareFunc void epicsShareAPI epicsTimerCancel(epicsTimerQueueId id);
epicsTimerId id,double delaySeconds);
epicsShareFunc void epicsShareAPI epicsTimerCancel(epicsTimerId id);
/* GetExpireTime returns (0,1) if time (is not, is) given a value*/
epicsShareFunc int epicsShareAPI epicsTimerGetExpireTime(
epicsTimerQueueId id, epicsTimeStamp *time);
epicsShareFunc int epicsShareAPI epicsTimerIsExpired(epicsTimerQueueId id);
epicsTimerId id, epicsTimeStamp *time);
/* epicsTimerIsExpired returns (0,1) if timer (is not, is) expired*/
epicsShareFunc int epicsShareAPI epicsTimerIsExpired(epicsTimerId id);
epicsShareFunc void epicsShareAPI epicsTimerShow(
epicsTimerQueueId id, unsigned int level);
epicsShareFunc epicsTimerQueueId epicsShareAPI
epicsTimerQueueCreate(unsigned int threadPriority);
epicsShareFunc void epicsShareAPI epicsTimerQueueDelete(epicsTimerQueueId);
epicsTimerId id, unsigned int level);
#ifdef __cplusplus
}

71
src/libCom/timer/epicsTimerQueue.h
View File

@@ -1,71 +0,0 @@
/* epicsTimerQueue.h */
/* Author: Jeffrey O. Hill */
/********************COPYRIGHT NOTIFICATION**********************************
This software was developed under a United States Government license
described on the COPYRIGHT_Combined file included as part
of this distribution.
****************************************************************************/
#ifndef epicsTimerQueueH
#define epicsTimerQueueH
#include "epicsTimer.h"
#include "epicsThread.h"
#ifdef __cplusplus
#include "epicsTimer.h"
class epicsTimerQueue {
public:
epicsTimerQueue();
virtual ~epicsTimerQueue() = 0;
epicsTime &getExpirationTime() const;
double getExpirationDelay() const;
virtual void show(unsigned int level) const;
protected:
class impl &queuePvt;
friend class epicsTimer;
private:
//copy constructor and operator= not allowed
epicsTimerQueue(const epicsTimerQueue& rhs);
epicsTimerQueue& operator=(const epicsTimerQueue& rhs);
};
class epicsTimerQueueThreaded : public epicsTimerQueue {
public:
epicsTimerQueueThreaded(
int threadPriority = epicsThreadPriorityMin+10);
virtual ~epicsTimerQueueThreaded();
int getPriority();
virtual void show(int level) const;
private:
class threadedImpl& threadPvt;
friend class epicsTimer;
//copy constructor and operator= not allowed
epicsTimerQueueThreaded(const epicsTimerQueueThreaded& rhs);
epicsTimerQueueThreaded& operator=
(const epicsTimerQueueThreaded& rhs);
};
class epicsTimerQueueNonthreaded : public epicsTimerQueue{
public:
epicsTimerQueueNonthreaded();
virtual ~epicsTimerQueueNonthreaded();
void process();
virtual void show(int level) const;
private:
class nothreadImpl& nothreadPvt;
friend class epicsTimer;
//copy constructor and operator= not allowed
epicsTimerQueueNonthreaded(
const epicsTimerQueueNonthreaded& rhs);
epicsTimerQueueNonthreaded&
operator=(const epicsTimerQueueNonthreaded& rhs);
};
#endif /* __cplusplus */
#endif /*epicsTimerQueueH*/