From 6362b22f68e543462544b14b480b9236acea10b0 Mon Sep 17 00:00:00 2001 From: hades Date: Wed, 14 Mar 2001 19:41:57 +0000 Subject: [PATCH] *** empty log message *** --- allParam/ca/server/Makefile | 16 +- allParam/ca/server/paramBlobRecord.cc | 139 ++++++++++++++++ allParam/ca/server/paramBlobRecord.h | 26 +++ ...ramGetRecord.cc => paramFilenameRecord.cc} | 27 ++-- allParam/ca/server/paramFilenameRecord.h | 26 +++ allParam/ca/server/paramIntRecord.cc | 150 ++++++++++++++++++ .../{paramGetRecord.h => paramIntRecord.h} | 16 +- allParam/ca/server/paramRecord.cc | 13 +- allParam/ca/server/paramRecord.h | 6 + allParam/ca/server/paramRecordSet.cc | 103 +++++------- allParam/ca/server/paramRecordSet.h | 4 +- allParam/ca/server/paramServer.cc | 2 +- allParam/ca/server/paramStoreRecord.cc | 62 -------- allParam/ca/server/paramStoreRecord.h | 22 --- allParam/ca/server/paramStringRecord.cc | 150 ++++++++++++++++++ allParam/ca/server/paramStringRecord.h | 26 +++ 16 files changed, 604 insertions(+), 184 deletions(-) create mode 100644 allParam/ca/server/paramBlobRecord.cc create mode 100644 allParam/ca/server/paramBlobRecord.h rename allParam/ca/server/{paramGetRecord.cc => paramFilenameRecord.cc} (77%) create mode 100644 allParam/ca/server/paramFilenameRecord.h create mode 100644 allParam/ca/server/paramIntRecord.cc rename allParam/ca/server/{paramGetRecord.h => paramIntRecord.h} (56%) delete mode 100644 allParam/ca/server/paramStoreRecord.cc delete mode 100644 allParam/ca/server/paramStoreRecord.h create mode 100644 allParam/ca/server/paramStringRecord.cc create mode 100644 allParam/ca/server/paramStringRecord.h diff --git a/allParam/ca/server/Makefile b/allParam/ca/server/Makefile index 2bb7f1d..9e87ad4 100644 --- a/allParam/ca/server/Makefile +++ b/allParam/ca/server/Makefile @@ -11,8 +11,8 @@ LOADLIBES = -L$(EPICS_BASE)/lib/$(HOST_ARCH) -lcas -lgdd -lca -lCom # Objects -OBJS = record.o paramRecord.o paramGetRecord.o paramStoreRecord.o \ - paramRecordSet.o paramServer.o +OBJS = record.o paramRecord.o paramIntRecord.o paramStringRecord.o \ + paramFilenameRecord.o paramBlobRecord.o paramRecordSet.o paramServer.o ########### # Targets # @@ -44,14 +44,18 @@ daq_param_cas : $(OBJS) paramServer.o: paramServer.cc paramRecordSet.h \ paramRecord.h record.h -paramRecordSet.o: paramRecordSet.cc paramRecordSet.h paramGetRecord.h \ - paramStoreRecord.h paramRecord.h record.h +paramRecordSet.o: paramRecordSet.cc paramRecordSet.h \ + paramIntRecord.h paramStringRecord.h paramFilenameRecord.h paramBlobRecord.h \ + paramRecord.h record.h record.o : record.cc record.h paramRecord.o: paramRecord.cc paramRecord.h record.h -paramGetRecord.o: paramGetRecord.cc paramGetRecord.h paramRecord.h record.h -paramStoreRecord.o: paramStoreRecord.cc paramStoreRecord.h paramRecord.h \ +paramIntRecord.o: paramIntRecord.cc paramIntRecord.h paramRecord.h record.h +paramStringRecord.o: paramStringRecord.cc paramStringRecord.h paramRecord.h \ record.h +paramFilenameRecord.o: paramFilenameRecord.cc paramFilenameRecord.h \ + paramRecord.h record.h +paramBlobRecord.o: paramBlobRecord.cc paramBlobRecord.h paramRecord.h record.h # Libraries as sources for the server diff --git a/allParam/ca/server/paramBlobRecord.cc b/allParam/ca/server/paramBlobRecord.cc new file mode 100644 index 0000000..a29b87b --- /dev/null +++ b/allParam/ca/server/paramBlobRecord.cc @@ -0,0 +1,139 @@ +#define _POSIX_C_SOURCE 199509L + +extern "C" { + #include +} + +#include "paramBlobRecord.h" + +ParamBlobRecord::ParamBlobRecord(caServer& cas, const Param *p, const char *rn, const char *u) : + ParamRecord(cas, p, rn, u) +{ + index = 0; + funcTable.installReadFunc("units", &Record::readUnits); + funcTable.installReadFunc("status", &Record::readStatus); + funcTable.installReadFunc("severity", &Record::readSeverity); + + funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl); + funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl); + funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr); + funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr); + funcTable.installReadFunc("precision", &ParamRecord::readPrecision); + + funcTable.installReadFunc("value", &ParamBlobRecord::readValue); +} + +ParamBlobRecord::~ParamBlobRecord() +{ + for(int k = 0 ; k < index ; k++) { + delete ourValue[k]; + } +} + +aitBool ParamBlobRecord::paramDoesReallyExist() +{ + aitBool retVal = aitFalse; + for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) { + ourValue[k] = new char[PARAM_MAX_VALUE_LEN]; + } + + int rows; + + if((Param_getStringArray(param, name, idx, PARAM_MAX_ARRAY_LEN, &rows, ourValue) == 0) && (rows > 0)) { + index = rows; + retVal = aitTrue; + } + + for(int k = index ; k < PARAM_MAX_ARRAY_LEN ; k++) { + delete ourValue[k]; + } + return retVal; +} + +epicsShareFunc unsigned ParamBlobRecord::maxDimension() const +{ + return 1u; +} + +epicsShareFunc aitIndex ParamBlobRecord::maxBound(unsigned dimension) const +{ + aitIndex retVal; + if(dimension == 0) { + retVal = index; + } else { + retVal = 1u; + } + return retVal; +} + +gddAppFuncTableStatus ParamBlobRecord::readValue(gdd &value) +{ + if(index == 1) { + aitString stringValue = new aitString; + + stringValue = ourValue[0]; + + value.putConvert(stringValue); + } else { + aitString *stringValue; + stringValue = new aitString[index]; + for (int k = 0 ; k < index ; k++) { + stringValue[k] = ourValue[k]; + } + + value.putRef(stringValue); + } + + return S_casApp_success; +} + +caStatus ParamBlobRecord::scan() +{ + caStatus retVal; + caServer *pCAS = this->getCAS(); + + if(index == 1) { + aitString stringValue = new aitString; + val = new gddScalar(gddAppType_value, aitEnumString); + + stringValue = ourValue[0]; + + val->putConvert(stringValue); + } else { + aitString *stringValue; + + val = new gddAtomic(gddAppType_value, aitEnumString, 1, index); + + stringValue = new aitString[index]; + for (int k = 0 ; k < index ; k++) { + stringValue[k] = ourValue[k]; + } + + ArrayDestructor *pDest = new ArrayDestructor; + + val->putRef(stringValue, pDest); + } + + val->setStat(epicsAlarmNone); + val->setSevr(epicsSevNone); + + if (this->interest == aitTrue && pCAS != NULL) { + casEventMask select(pCAS->valueEventMask|pCAS->logEventMask|pCAS->alarmEventMask); + this->postEvent (select, *val); + } + + retVal = S_cas_success; + + return retVal; +} + +caStatus ParamBlobRecord::read(const casCtx &ctx, gdd &prototype) +{ + return ((scan() == S_cas_success) && funcTable.read(*this, prototype)); +} + +caStatus ParamBlobRecord::write(const casCtx &ctx, gdd &value) +{ + return S_cas_noWrite; +} + diff --git a/allParam/ca/server/paramBlobRecord.h b/allParam/ca/server/paramBlobRecord.h new file mode 100644 index 0000000..f071c22 --- /dev/null +++ b/allParam/ca/server/paramBlobRecord.h @@ -0,0 +1,26 @@ +#ifndef PARAMBLOBRECORD_H +#define PARAMBLOBRECORD_H + +#include "paramRecord.h" + +class ParamBlobRecord : public ParamRecord { + private: + aitIndex index; + char *ourValue[PARAM_MAX_ARRAY_LEN]; + gddAppFuncTable funcTable; + + public: + ParamBlobRecord(caServer&, const Param *, const char *, const char *); + ~ParamBlobRecord(); + + aitBool paramDoesReallyExist(); + epicsShareFunc unsigned maxDimension() const; + epicsShareFunc aitIndex maxBound(unsigned int) const; + gddAppFuncTableStatus readValue(gdd &); + caStatus scan(); + caStatus read(const casCtx &, gdd &); + caStatus write(const casCtx &, gdd &); +}; + +#endif + diff --git a/allParam/ca/server/paramGetRecord.cc b/allParam/ca/server/paramFilenameRecord.cc similarity index 77% rename from allParam/ca/server/paramGetRecord.cc rename to allParam/ca/server/paramFilenameRecord.cc index 71dbf6b..b2d20dd 100644 --- a/allParam/ca/server/paramGetRecord.cc +++ b/allParam/ca/server/paramFilenameRecord.cc @@ -4,14 +4,9 @@ extern "C" { #include } -#include "paramGetRecord.h" +#include "paramFilenameRecord.h" -void ArrayDestructor::run(void *todelete) { - aitString *pd = (aitString *) todelete; - delete [] pd; -} - -ParamGetRecord::ParamGetRecord(caServer& cas, const Param *p, const char *rn, const char *u) : +ParamFilenameRecord::ParamFilenameRecord(caServer& cas, const Param *p, const char *rn, const char *u) : ParamRecord(cas, p, rn, u) { index = 0; @@ -25,17 +20,17 @@ ParamGetRecord::ParamGetRecord(caServer& cas, const Param *p, const char *rn, co funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr); funcTable.installReadFunc("precision", &ParamRecord::readPrecision); - funcTable.installReadFunc("value", &ParamGetRecord::readValue); + funcTable.installReadFunc("value", &ParamFilenameRecord::readValue); } -ParamGetRecord::~ParamGetRecord() +ParamFilenameRecord::~ParamFilenameRecord() { for(int k = 0 ; k < index ; k++) { delete ourValue[k]; } } -aitBool ParamGetRecord::paramDoesReallyExist() +aitBool ParamFilenameRecord::paramDoesReallyExist() { aitBool retVal = aitFalse; for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) { @@ -55,12 +50,12 @@ aitBool ParamGetRecord::paramDoesReallyExist() return retVal; } -epicsShareFunc unsigned ParamGetRecord::maxDimension() const +epicsShareFunc unsigned ParamFilenameRecord::maxDimension() const { return 1u; } -epicsShareFunc aitIndex ParamGetRecord::maxBound(unsigned dimension) const +epicsShareFunc aitIndex ParamFilenameRecord::maxBound(unsigned dimension) const { aitIndex retVal; if(dimension == 0) { @@ -71,7 +66,7 @@ epicsShareFunc aitIndex ParamGetRecord::maxBound(unsigned dimension) const return retVal; } -gddAppFuncTableStatus ParamGetRecord::readValue(gdd &value) +gddAppFuncTableStatus ParamFilenameRecord::readValue(gdd &value) { if(index == 1) { aitString stringValue = new aitString; @@ -92,7 +87,7 @@ gddAppFuncTableStatus ParamGetRecord::readValue(gdd &value) return S_casApp_success; } -caStatus ParamGetRecord::scan() +caStatus ParamFilenameRecord::scan() { caStatus retVal; caServer *pCAS = this->getCAS(); @@ -132,12 +127,12 @@ caStatus ParamGetRecord::scan() return retVal; } -caStatus ParamGetRecord::read(const casCtx &ctx, gdd &prototype) +caStatus ParamFilenameRecord::read(const casCtx &ctx, gdd &prototype) { return ((scan() == S_cas_success) && funcTable.read(*this, prototype)); } -caStatus ParamGetRecord::write(const casCtx &ctx, gdd &value) +caStatus ParamFilenameRecord::write(const casCtx &ctx, gdd &value) { return S_cas_noWrite; } diff --git a/allParam/ca/server/paramFilenameRecord.h b/allParam/ca/server/paramFilenameRecord.h new file mode 100644 index 0000000..6e32a09 --- /dev/null +++ b/allParam/ca/server/paramFilenameRecord.h @@ -0,0 +1,26 @@ +#ifndef PARAMFILENAMERECORD_H +#define PARAMFILENAMERECORD_H + +#include "paramRecord.h" + +class ParamFilenameRecord : public ParamRecord { + private: + aitIndex index; + char *ourValue[PARAM_MAX_ARRAY_LEN]; + gddAppFuncTable funcTable; + + public: + ParamFilenameRecord(caServer&, const Param *, const char *, const char *); + ~ParamFilenameRecord(); + + aitBool paramDoesReallyExist(); + epicsShareFunc unsigned maxDimension() const; + epicsShareFunc aitIndex maxBound(unsigned int) const; + gddAppFuncTableStatus readValue(gdd &); + caStatus scan(); + caStatus read(const casCtx &, gdd &); + caStatus write(const casCtx &, gdd &); +}; + +#endif + diff --git a/allParam/ca/server/paramIntRecord.cc b/allParam/ca/server/paramIntRecord.cc new file mode 100644 index 0000000..7d37f3f --- /dev/null +++ b/allParam/ca/server/paramIntRecord.cc @@ -0,0 +1,150 @@ +#define _POSIX_C_SOURCE 199509L + +extern "C" { + #include +} + +#include "paramIntRecord.h" + +ParamIntRecord::ParamIntRecord(caServer& cas, const Param *p, const char *rn, const char *u) : + ParamRecord(cas, p, rn, u) +{ + index = 0; + funcTable.installReadFunc("units", &Record::readUnits); + funcTable.installReadFunc("status", &Record::readStatus); + funcTable.installReadFunc("severity", &Record::readSeverity); + + funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl); + funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl); + funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr); + funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr); + funcTable.installReadFunc("precision", &ParamRecord::readPrecision); + + funcTable.installReadFunc("value", &ParamIntRecord::readValue); +} + +ParamIntRecord::~ParamIntRecord() +{ + for(int k = 0 ; k < index ; k++) { + delete ourValue[k]; + } +} + +aitBool ParamIntRecord::paramDoesReallyExist() +{ + aitBool retVal = aitFalse; + for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) { + ourValue[k] = new char[PARAM_MAX_VALUE_LEN]; + } + + int rows; + + if((Param_getStringArray(param, name, idx, PARAM_MAX_ARRAY_LEN, &rows, ourValue) == 0) && (rows > 0)) { + index = rows; + retVal = aitTrue; + } + + for(int k = index ; k < PARAM_MAX_ARRAY_LEN ; k++) { + delete ourValue[k]; + } + return retVal; +} + +epicsShareFunc unsigned ParamIntRecord::maxDimension() const +{ + return 1u; +} + +epicsShareFunc aitIndex ParamIntRecord::maxBound(unsigned dimension) const +{ + aitIndex retVal; + if(dimension == 0) { + retVal = index; + } else { + retVal = 1u; + } + return retVal; +} + +gddAppFuncTableStatus ParamIntRecord::readValue(gdd &value) +{ + if(index == 1) { + aitString stringValue = new aitString; + + stringValue = ourValue[0]; + + value.putConvert(stringValue); + } else { + aitString *stringValue; + stringValue = new aitString[index]; + for (int k = 0 ; k < index ; k++) { + stringValue[k] = ourValue[k]; + } + + value.putRef(stringValue); + } + + return S_casApp_success; +} + +caStatus ParamIntRecord::scan() +{ + caStatus retVal; + caServer *pCAS = this->getCAS(); + + if(index == 1) { + aitString stringValue = new aitString; + val = new gddScalar(gddAppType_value, aitEnumString); + + stringValue = ourValue[0]; + + val->putConvert(stringValue); + } else { + aitString *stringValue; + + val = new gddAtomic(gddAppType_value, aitEnumString, 1, index); + + stringValue = new aitString[index]; + for (int k = 0 ; k < index ; k++) { + stringValue[k] = ourValue[k]; + } + + ArrayDestructor *pDest = new ArrayDestructor; + + val->putRef(stringValue, pDest); + } + + val->setStat(epicsAlarmNone); + val->setSevr(epicsSevNone); + + if (this->interest == aitTrue && pCAS != NULL) { + casEventMask select(pCAS->valueEventMask|pCAS->logEventMask|pCAS->alarmEventMask); + this->postEvent (select, *val); + } + + retVal = S_cas_success; + + return retVal; +} + +caStatus ParamIntRecord::read(const casCtx &ctx, gdd &prototype) +{ + return ((scan() == S_cas_success) && funcTable.read(*this, prototype)); +} + +caStatus ParamIntRecord::write(const casCtx &ctx, gdd &value) +{ + caServer *pCAS = this->getCAS(); + + aitString stringValue; + + value.getConvert(stringValue); + + char ourValue[PARAM_MAX_VALUE_LEN]; + strcpy(ourValue, (const char *) stringValue); + + Param_storeString(param, name, idx, ourValue); + + return S_cas_success; +} + diff --git a/allParam/ca/server/paramGetRecord.h b/allParam/ca/server/paramIntRecord.h similarity index 56% rename from allParam/ca/server/paramGetRecord.h rename to allParam/ca/server/paramIntRecord.h index ae9ada5..5f7e6b5 100644 --- a/allParam/ca/server/paramGetRecord.h +++ b/allParam/ca/server/paramIntRecord.h @@ -1,21 +1,17 @@ -#ifndef PARAMGETRECORD_H -#define PARAMGETRECORD_H +#ifndef PARAMINTRECORD_H +#define PARAMINTRECORD_H #include "paramRecord.h" -class ArrayDestructor : public gddDestructor { - virtual void run(void *); -}; - -class ParamGetRecord : public ParamRecord { +class ParamIntRecord : public ParamRecord { private: aitIndex index; char *ourValue[PARAM_MAX_ARRAY_LEN]; - gddAppFuncTable funcTable; + gddAppFuncTable funcTable; public: - ParamGetRecord(caServer&, const Param *, const char *, const char *); - ~ParamGetRecord(); + ParamIntRecord(caServer&, const Param *, const char *, const char *); + ~ParamIntRecord(); aitBool paramDoesReallyExist(); epicsShareFunc unsigned maxDimension() const; diff --git a/allParam/ca/server/paramRecord.cc b/allParam/ca/server/paramRecord.cc index b3e6630..5b77e8c 100644 --- a/allParam/ca/server/paramRecord.cc +++ b/allParam/ca/server/paramRecord.cc @@ -8,6 +8,11 @@ extern "C" { #include "paramRecord.h" +void ArrayDestructor::run(void *todelete) { + aitString *pd = (aitString *) todelete; + delete [] pd; +} + ParamRecord::ParamRecord(caServer& cas, const Param *p, const char *rn, const char *u) : Record(cas, rn, u, aitEnumString), param(p) { @@ -16,10 +21,11 @@ ParamRecord::ParamRecord(caServer& cas, const Param *p, const char *rn, const ch char buf2[PARAM_MAX_NAME_LEN]; char buf3[PARAM_MAX_NAME_LEN]; + strcpy(pPVName, rn); strcpy(buf1, ""); strcpy(buf2, ""); strcpy(buf3, ""); - sscanf(rn, "HAD:P%c:%[^:]:%[^:]:%[^:]", &tmp, buf1, buf2, buf3); + sscanf(pPVName, "HAD:P%c:%[^:]:%[^:]:%[^:]", &tmp, buf1, buf2, buf3); if(strcmp(buf3, "") == 0) { strcpy(name, buf1); strcpy(idx, buf2); @@ -46,6 +52,11 @@ epicsShareFunc aitEnum ParamRecord::bestExternalType() const return aitEnumString; } +const char *ParamRecord::getPVName() +{ + return pPVName; +} + gddAppFuncTableStatus ParamRecord::readLowCtrl(gdd &value) { value.putConvert(0); diff --git a/allParam/ca/server/paramRecord.h b/allParam/ca/server/paramRecord.h index 4eb5551..af6e703 100644 --- a/allParam/ca/server/paramRecord.h +++ b/allParam/ca/server/paramRecord.h @@ -9,15 +9,21 @@ extern "C" { #include "record.h" +class ArrayDestructor : public gddDestructor { + virtual void run(void *); +}; + class ParamRecord : public Record { protected: const Param *param; + char pPVName[PARAM_MAX_VALUE_LEN]; char name[PARAM_MAX_VALUE_LEN]; char idx[PARAM_MAX_VALUE_LEN]; public: ParamRecord(caServer&, const Param *, const char *, const char *); ~ParamRecord(); + const char *getPVName(); epicsShareFunc aitEnum bestExternalType() const; virtual gddAppFuncTableStatus readLowCtrl(gdd &); diff --git a/allParam/ca/server/paramRecordSet.cc b/allParam/ca/server/paramRecordSet.cc index 8c2d3ec..760b9df 100644 --- a/allParam/ca/server/paramRecordSet.cc +++ b/allParam/ca/server/paramRecordSet.cc @@ -9,8 +9,10 @@ extern "C" { } #include "paramRecordSet.h" -#include "paramGetRecord.h" -#include "paramStoreRecord.h" +#include "paramIntRecord.h" +#include "paramStringRecord.h" +#include "paramFilenameRecord.h" +#include "paramBlobRecord.h" ParamRecordSet::ParamRecordSet(unsigned int pvCountEstimate) : caServer(pvCountEstimate) @@ -46,6 +48,7 @@ Param *ParamRecordSet::pParam(const char *setup) pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName) { char *setup; + char type; char buf1[PARAM_MAX_NAME_LEN]; char buf2[PARAM_MAX_NAME_LEN]; char buf3[PARAM_MAX_NAME_LEN]; @@ -53,37 +56,20 @@ pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName strcpy(buf1, ""); strcpy(buf2, ""); strcpy(buf3, ""); - if(strncmp(pPVName, "HAD:PS:", strlen("HAD:PS:")) == 0) { - sscanf(pPVName, "HAD:PS:[^:]:[^:]:[^:]", buf1, buf2, buf3); - if (strcmp(buf3, "") == 0) { - setup = NULL; - } else { - setup = buf1; - for (int i = 0 ; i < strlen(setup) ; i++) { - setup[i] = tolower(setup[i]); - } - } - if(pParam(setup) == NULL) { - param[numParamSrc] = new Param; - if (conSetupParam(param[numParamSrc], setup) == 0) { - numParamSrc++; - } else { - desParam(param[numParamSrc]); - delete param[numParamSrc]; - } - } - if(pParam(setup) != NULL) { + + for (int i = 0 ; i < numPv ; i++) { + if(strcmp(pPVName, pvs[i]->getPVName()) == 0) { return pverExistsHere; - } else { - return pverDoesNotExistHere; } - } else if(strncmp(pPVName, "HAD:PG:", strlen("HAD:PG:")) == 0) { - sscanf(pPVName, "HAD:PG:[^:]:[^:]:[^:]", buf1, buf2, buf3); + } + + if(strncmp(pPVName, "HAD:P", strlen("HAD:P")) == 0) { + sscanf(pPVName, "HAD:P%c:[^:]:[^:]:[^:]", &type, buf1, buf2, buf3); if (strcmp(buf3, "") == 0) { setup = NULL; } else { setup = buf1; - for (int i = 0 ; i < strlen(setup) ; i++) { + for (unsigned int i = 0 ; i < strlen(setup) ; i++) { setup[i] = tolower(setup[i]); } } @@ -97,14 +83,7 @@ pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName } } if(pParam(setup) != NULL) { - ParamGetRecord *record = new ParamGetRecord(*this, pParam(setup), pPVName, "String Array"); - if(record->paramDoesReallyExist()) { - delete record; - return pverExistsHere; - } else { - delete record; - return pverDoesNotExistHere; - } + return pverExistsHere; } else { return pverDoesNotExistHere; } @@ -114,51 +93,47 @@ pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName pvCreateReturn ParamRecordSet::createPV(const casCtx &ctx, const char *pPVName) { - pvCreateReturn retVal(S_casApp_pvNotFound); char *setup; + char type; char buf1[PARAM_MAX_NAME_LEN]; char buf2[PARAM_MAX_NAME_LEN]; char buf3[PARAM_MAX_NAME_LEN]; - strcpy(buf1, ""); - strcpy(buf2, ""); - strcpy(buf3, ""); - if(strncmp(pPVName, "HAD:PS:", strlen("HAD:PS:")) == 0) { - sscanf(pPVName, "HAD:PS:[^:]:[^:]:[^:]", buf1, buf2, buf3); - if (strcmp(buf3, "") == 0) { - setup = NULL; - } else { - setup = buf1; - for (int i = 0 ; i < strlen(setup) ; i++) { - setup[i] = tolower(setup[i]); - } - } - if(pParam(setup) != NULL) { - retVal = (pvs[numPv++] = new ParamStoreRecord(*this, pParam(setup), pPVName, "String")); + pvCreateReturn retVal(S_casApp_pvNotFound); + + for (int i = 0 ; i < numPv ; i++) { + if(strcmp(pPVName, pvs[i]->getPVName()) == 0) { + retVal = pvs[i]; return retVal; - } else { - return S_casApp_pvNotFound; } - } else if(strncmp(pPVName, "HAD:PG:", strlen("HAD:PG:")) == 0) { - sscanf(pPVName, "HAD:PG:[^:]:[^:]:[^:]", buf1, buf2, buf3); + } + + if(strncmp(pPVName, "HAD:P", strlen("HAD:P")) == 0) { + sscanf(pPVName, "HAD:P%c:[^:]:[^:]:[^:]", &type, buf1, buf2, buf3); if (strcmp(buf3, "") == 0) { setup = NULL; } else { setup = buf1; - for (int i = 0 ; i < strlen(setup) ; i++) { + for (unsigned int i = 0 ; i < strlen(setup) ; i++) { setup[i] = tolower(setup[i]); } } if(pParam(setup) != NULL) { - ParamGetRecord *record = new ParamGetRecord(*this, pParam(setup), pPVName, "String Array"); - if(record->paramDoesReallyExist()) { - pvs[numPv++] = record; - retVal = record; - return retVal; - } else { - delete record; - return S_casApp_pvNotFound; + switch (type) { + case('I'): + retVal = (pvs[numPv++] = new ParamIntRecord(*this, pParam(setup), pPVName, "Integer")); + break; + case('S'): + retVal = (pvs[numPv++] = new ParamStringRecord(*this, pParam(setup), pPVName, "String")); + break; + case('F'): + retVal = (pvs[numPv++] = new ParamFilenameRecord(*this, pParam(setup), pPVName, "Filename")); + break; + case('B'): + retVal = (pvs[numPv++] = new ParamBlobRecord(*this, pParam(setup), pPVName, "Binary Large OBject")); + break; } + return retVal; } else { return S_casApp_pvNotFound; } diff --git a/allParam/ca/server/paramRecordSet.h b/allParam/ca/server/paramRecordSet.h index d1b3662..cf72ddf 100644 --- a/allParam/ca/server/paramRecordSet.h +++ b/allParam/ca/server/paramRecordSet.h @@ -10,12 +10,12 @@ extern "C" { #include "paramRecord.h" #define MAX_PARAM_SRC 16 -#define PV_COUNT_EST 1024 +#define MAX_NUM_PV 1024 class ParamRecordSet : public caServer { private: int numPv; - ParamRecord *pvs[PV_COUNT_EST]; + ParamRecord *pvs[MAX_NUM_PV]; int numParamSrc; Param *param[MAX_PARAM_SRC]; diff --git a/allParam/ca/server/paramServer.cc b/allParam/ca/server/paramServer.cc index c0d2a51..ee7d7e8 100644 --- a/allParam/ca/server/paramServer.cc +++ b/allParam/ca/server/paramServer.cc @@ -19,7 +19,7 @@ int main(int argc, char *argv[]) { ParamRecordSet *cas; - if (NULL == (cas = new ParamRecordSet(PV_COUNT_EST))) { + if (NULL == (cas = new ParamRecordSet(MAX_NUM_PV))) { syslog(LOG_ERR, "Cannot allocate memory for the RecordSet. Exiting.\n"); exit(-1); } diff --git a/allParam/ca/server/paramStoreRecord.cc b/allParam/ca/server/paramStoreRecord.cc deleted file mode 100644 index e226e3e..0000000 --- a/allParam/ca/server/paramStoreRecord.cc +++ /dev/null @@ -1,62 +0,0 @@ -#define _POSIX_C_SOURCE 199509L - -extern "C" { - #include -} - -#include "paramStoreRecord.h" - -ParamStoreRecord::ParamStoreRecord(caServer& cas, const Param *p, const char *rn, const char *u) : - ParamRecord(cas, p, rn, u) -{ - funcTable.installReadFunc("units", &Record::readUnits); - funcTable.installReadFunc("status", &Record::readStatus); - funcTable.installReadFunc("severity", &Record::readSeverity); - - funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl); - funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl); - funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr); - funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr); - funcTable.installReadFunc("precision", &ParamRecord::readPrecision); - - funcTable.installReadFunc("value", &ParamStoreRecord::readValue); -} - -ParamStoreRecord::~ParamStoreRecord() -{ -} - -gddAppFuncTableStatus ParamStoreRecord::readValue(gdd &value) -{ - return S_casApp_noSupport; -} - -caStatus ParamStoreRecord::scan() -{ - return S_casApp_noSupport; -} - -caStatus ParamStoreRecord::read(const casCtx &ctx, gdd &prototype) -{ - return S_casApp_noSupport; -} - -caStatus ParamStoreRecord::write(const casCtx &ctx, gdd &value) -{ - fprintf(stderr, "Entered ParamStoreRecord::write\n"); - caServer *pCAS = this->getCAS(); - - aitString stringValue; - - value.getConvert(stringValue); - - char ourValue[PARAM_MAX_VALUE_LEN]; - strcpy(ourValue, (const char *) stringValue); - fprintf(stderr, "ourValue to write: %s\n", ourValue); - - Param_storeString(param, name, idx, ourValue); - - fprintf(stderr, "Leaving ParamStoreRecord::write\n"); - return S_cas_success; -} - diff --git a/allParam/ca/server/paramStoreRecord.h b/allParam/ca/server/paramStoreRecord.h deleted file mode 100644 index 154a871..0000000 --- a/allParam/ca/server/paramStoreRecord.h +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef PARAMSTORERECORD_H -#define PARAMSTORERECORD_H - -#include "paramRecord.h" - -class ParamStoreRecord : public ParamRecord { - private: - aitIndex index; - gddAppFuncTable funcTable; - - public: - ParamStoreRecord(caServer&, const Param *, const char *, const char *); - ~ParamStoreRecord(); - - gddAppFuncTableStatus readValue(gdd &); - caStatus scan(); - caStatus read(const casCtx &, gdd &); - caStatus write(const casCtx &, gdd &); -}; - -#endif - diff --git a/allParam/ca/server/paramStringRecord.cc b/allParam/ca/server/paramStringRecord.cc new file mode 100644 index 0000000..438ea07 --- /dev/null +++ b/allParam/ca/server/paramStringRecord.cc @@ -0,0 +1,150 @@ +#define _POSIX_C_SOURCE 199509L + +extern "C" { + #include +} + +#include "paramStringRecord.h" + +ParamStringRecord::ParamStringRecord(caServer& cas, const Param *p, const char *rn, const char *u) : + ParamRecord(cas, p, rn, u) +{ + index = 0; + funcTable.installReadFunc("units", &Record::readUnits); + funcTable.installReadFunc("status", &Record::readStatus); + funcTable.installReadFunc("severity", &Record::readSeverity); + + funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl); + funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl); + funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr); + funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr); + funcTable.installReadFunc("precision", &ParamRecord::readPrecision); + + funcTable.installReadFunc("value", &ParamStringRecord::readValue); +} + +ParamStringRecord::~ParamStringRecord() +{ + for(int k = 0 ; k < index ; k++) { + delete ourValue[k]; + } +} + +aitBool ParamStringRecord::paramDoesReallyExist() +{ + aitBool retVal = aitFalse; + for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) { + ourValue[k] = new char[PARAM_MAX_VALUE_LEN]; + } + + int rows; + + if((Param_getStringArray(param, name, idx, PARAM_MAX_ARRAY_LEN, &rows, ourValue) == 0) && (rows > 0)) { + index = rows; + retVal = aitTrue; + } + + for(int k = index ; k < PARAM_MAX_ARRAY_LEN ; k++) { + delete ourValue[k]; + } + return retVal; +} + +epicsShareFunc unsigned ParamStringRecord::maxDimension() const +{ + return 1u; +} + +epicsShareFunc aitIndex ParamStringRecord::maxBound(unsigned dimension) const +{ + aitIndex retVal; + if(dimension == 0) { + retVal = index; + } else { + retVal = 1u; + } + return retVal; +} + +gddAppFuncTableStatus ParamStringRecord::readValue(gdd &value) +{ + if(index == 1) { + aitString stringValue = new aitString; + + stringValue = ourValue[0]; + + value.putConvert(stringValue); + } else { + aitString *stringValue; + stringValue = new aitString[index]; + for (int k = 0 ; k < index ; k++) { + stringValue[k] = ourValue[k]; + } + + value.putRef(stringValue); + } + + return S_casApp_success; +} + +caStatus ParamStringRecord::scan() +{ + caStatus retVal; + caServer *pCAS = this->getCAS(); + + if(index == 1) { + aitString stringValue = new aitString; + val = new gddScalar(gddAppType_value, aitEnumString); + + stringValue = ourValue[0]; + + val->putConvert(stringValue); + } else { + aitString *stringValue; + + val = new gddAtomic(gddAppType_value, aitEnumString, 1, index); + + stringValue = new aitString[index]; + for (int k = 0 ; k < index ; k++) { + stringValue[k] = ourValue[k]; + } + + ArrayDestructor *pDest = new ArrayDestructor; + + val->putRef(stringValue, pDest); + } + + val->setStat(epicsAlarmNone); + val->setSevr(epicsSevNone); + + if (this->interest == aitTrue && pCAS != NULL) { + casEventMask select(pCAS->valueEventMask|pCAS->logEventMask|pCAS->alarmEventMask); + this->postEvent (select, *val); + } + + retVal = S_cas_success; + + return retVal; +} + +caStatus ParamStringRecord::read(const casCtx &ctx, gdd &prototype) +{ + return ((scan() == S_cas_success) && funcTable.read(*this, prototype)); +} + +caStatus ParamStringRecord::write(const casCtx &ctx, gdd &value) +{ + caServer *pCAS = this->getCAS(); + + aitString stringValue; + + value.getConvert(stringValue); + + char ourValue[PARAM_MAX_VALUE_LEN]; + strcpy(ourValue, (const char *) stringValue); + + Param_storeString(param, name, idx, ourValue); + + return S_cas_success; +} + diff --git a/allParam/ca/server/paramStringRecord.h b/allParam/ca/server/paramStringRecord.h new file mode 100644 index 0000000..83512b6 --- /dev/null +++ b/allParam/ca/server/paramStringRecord.h @@ -0,0 +1,26 @@ +#ifndef PARAMSTRINGRECORD_H +#define PARAMSTRINGRECORD_H + +#include "paramRecord.h" + +class ParamStringRecord : public ParamRecord { + private: + aitIndex index; + char *ourValue[PARAM_MAX_ARRAY_LEN]; + gddAppFuncTable funcTable; + + public: + ParamStringRecord(caServer&, const Param *, const char *, const char *); + ~ParamStringRecord(); + + aitBool paramDoesReallyExist(); + epicsShareFunc unsigned maxDimension() const; + epicsShareFunc aitIndex maxBound(unsigned int) const; + gddAppFuncTableStatus readValue(gdd &); + caStatus scan(); + caStatus read(const casCtx &, gdd &); + caStatus write(const casCtx &, gdd &); +}; + +#endif + -- 2.43.0