string PvaClientData::getString()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getString\n";
PVScalarPtr pvScalar;
PVStructurePtr pvStructure = getPVStructure();
PVFieldPtr pvValue = pvStructure->getSubField("value");
if(pvValue) {
Type type = pvValue->getField()->getType();
if(type==scalar) pvScalar = static_pointer_cast<PVScalar>(pvValue);
}
if(!pvScalar) {
while(true) {
const PVFieldPtrArray fieldPtrArray(pvStructure->getPVFields());
if(fieldPtrArray.size()!=1) {
throw std::logic_error(
"PvaClientData::getString() pvRequest for multiple fields");
}
PVFieldPtr pvField(fieldPtrArray[0]);
Type type = pvField->getField()->getType();
if(type==scalar) {
pvScalar = static_pointer_cast<PVScalar>(pvField);
break;
}
if(pvField->getField()->getType()!=epics::pvData::structure) break;
pvStructure = static_pointer_cast<PVStructure>(pvField);
}
}
if(!pvScalar) {
throw std::logic_error(
"PvaClientData::getString() did not find a scalar field");
}
return convert->toString(pvScalar);
}
void NTNDArrayRecord::setDimension(const int32_t * dims, size_t ndims)
{
// Get the dimension field
PVStructureArrayPtr dimField = ndarray->getDimension();
// create a shared_vector or try to reuse the dimension field's one
PVStructureArray::svector dimVector(dimField->reuse());
// resize/reserve the number of elements
dimVector.resize(ndims);
// Iterate over the number of dimensions, creating and adding the
// appropriate dimension structures.
for (size_t i = 0; i < ndims; i++)
{
PVStructurePtr d = dimVector[i];
if (!d || !d.unique())
d = dimVector[i] = getPVDataCreate()->createPVStructure(dimField->getStructureArray()->getStructure());
d->getSubField<PVInt>("size")->put(dims[i]);
d->getSubField<PVInt>("offset")->put(0);
d->getSubField<PVInt>("fullSize")->put(dims[i]);
d->getSubField<PVInt>("binning")->put(1);
d->getSubField<PVBoolean>("reverse")->put(false);
}
// replace the dimensions field's shared_vector
// (Remember to freeze first)
dimField->replace(freeze(dimVector));
}
void PvaClientPut::getDone(
const Status& status,
ChannelPut::shared_pointer const & channelPut,
PVStructurePtr const & pvStructure,
BitSetPtr const & bitSet)
{
if(PvaClient::getDebug()) {
cout << "PvaClientPut::getDone"
<< " channelName " << pvaClientChannel->getChannel()->getChannelName()
<< " status.isOK " << (status.isOK() ? "true" : "false")
<< endl;
}
{
Lock xx(mutex);
channelGetPutStatus = status;
if(status.isOK()) {
PVStructurePtr pvs = pvaClientData->getPVStructure();
pvs->copyUnchecked(*pvStructure,*bitSet);
BitSetPtr bs = pvaClientData->getChangedBitSet();
bs->clear();
*bs |= *bitSet;
putState = putComplete;
}
}
PvaClientPutRequesterPtr req(pvaClientPutRequester.lock());
if(req) {
req->getDone(status,shared_from_this());
}
waitForGetPut.signal();
}
void ChannelPutGetLocal::getPut()
{
ChannelPutGetRequester::shared_pointer requester = channelPutGetRequester.lock();
if(!requester) return;
if(isDestroyed) {
requester->getPutDone(
channelDestroyedStatus,getPtrSelf(),nullPVStructure,nullBitSet);
return;
}
try {
PVStructurePtr pvPutStructure = pvPutCopy->createPVStructure();
BitSetPtr putBitSet(new BitSet(pvPutStructure->getNumberFields()));
{
epicsGuard <PVRecord> guard(*pvRecord);
pvPutCopy->initCopy(pvPutStructure, putBitSet);
}
requester->getPutDone(
Status::Ok,getPtrSelf(),pvPutStructure,putBitSet);
if(pvRecord->getTraceLevel()>1)
{
cout << "ChannelPutGetLocal::getPut" << endl;
}
} catch(std::exception& ex) {
Status status = Status(Status::STATUSTYPE_FATAL, ex.what());
PVStructurePtr pvPutStructure;
BitSetPtr putBitSet;
requester->getPutDone(status,getPtrSelf(),pvGetStructure,getBitSet);
}
}
static PVFieldPtr findSubField(
String const & fieldName,
PVStructure const *pvStructure)
{
if( fieldName.length()<1) return PVFieldPtr();
String::size_type index = fieldName.find('.');
String name = fieldName;
String restOfName = String();
if(index>0) {
name = fieldName.substr(0, index);
if(fieldName.length()>index) {
restOfName = fieldName.substr(index+1);
}
}
PVFieldPtrArray pvFields = pvStructure->getPVFields();
PVFieldPtr pvField;
size_t numFields = pvStructure->getStructure()->getNumberFields();
for(size_t i=0; i<numFields; i++) {
pvField = pvFields[i];
size_t result = pvField->getFieldName().compare(name);
if(result==0) {
if(restOfName.length()==0) return pvFields[i];
if(pvField->getField()->getType()!=structure) return PVFieldPtr();
PVStructurePtr pvStructure =
std::tr1::static_pointer_cast<PVStructure>(pvField);
return findSubField(restOfName,pvStructure.get());
}
}
return PVFieldPtr();
}
void test_wrap()
{
testDiag("test_wrap");
NTMultiChannelPtr nullPtr = NTMultiChannel::wrap(PVStructurePtr());
testOk(nullPtr.get() == 0, "nullptr wrap");
nullPtr = NTMultiChannel::wrap(
getPVDataCreate()->createPVStructure(
NTField::get()->createTimeStamp()
)
);
testOk(nullPtr.get() == 0, "wrong type wrap");
NTMultiChannelBuilderPtr builder = NTMultiChannel::createBuilder();
testOk(builder.get() != 0, "Got builder");
PVStructurePtr pvStructure = builder->
createPVStructure();
testOk1(pvStructure.get() != 0);
if (!pvStructure)
return;
NTMultiChannelPtr ptr = NTMultiChannel::wrap(pvStructure);
testOk(ptr.get() != 0, "wrap OK");
builder = NTMultiChannel::createBuilder();
ptr = NTMultiChannel::wrapUnsafe(pvStructure);
testOk(ptr.get() != 0, "wrapUnsafe OK");
}
void PVStructure::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pcontrol, BitSet *pbitSet) {
size_t offset = getFieldOffset();
size_t numberFields = getNumberFields();
int32 next = pbitSet->nextSetBit(offset);
// no more changes or no changes in this structure
if(next<0||next>=static_cast<int32>(offset+numberFields)) return;
// entire structure
if(static_cast<int32>(offset)==next) {
deserialize(pbuffer, pcontrol);
return;
}
size_t fieldsSize = pvFields.size();
for(size_t i = 0; i<fieldsSize; i++) {
PVFieldPtr pvField = pvFields[i];
offset = pvField->getFieldOffset();
int32 inumberFields = pvField->getNumberFields();
next = pbitSet->nextSetBit(offset);
// no more changes
if(next<0) return;
// no change in this pvField
if(next>=static_cast<int32>(offset+inumberFields)) continue;
// deserialize field or fields
if(inumberFields==1) {
pvField->deserialize(pbuffer, pcontrol);
} else {
PVStructurePtr pvStructure = std::tr1::static_pointer_cast<PVStructure>(pvField);
pvStructure->deserialize(pbuffer, pcontrol, pbitSet);
}
}
}
void test_wrap()
{
testDiag("test_wrap");
NTTablePtr nullPtr = NTTable::wrap(PVStructurePtr());
testOk(nullPtr.get() == 0, "nullptr wrap");
nullPtr = NTTable::wrap(
getPVDataCreate()->createPVStructure(
NTField::get()->createTimeStamp()
)
);
testOk(nullPtr.get() == 0, "wrong type wrap");
NTTableBuilderPtr builder = NTTable::createBuilder();
testOk(builder.get() != 0, "Got builder");
PVStructurePtr pvStructure = builder->
addColumn("column0", pvDouble)->
addColumn("column1", pvString)->
addColumn("column2", pvInt)->
createPVStructure();
testOk1(pvStructure.get() != 0);
if (!pvStructure)
return;
NTTablePtr ptr = NTTable::wrap(pvStructure);
testOk(ptr.get() != 0, "wrap OK");
ptr = NTTable::wrapUnsafe(pvStructure);
testOk(ptr.get() != 0, "wrapUnsafe OK");
}
void test_labels()
{
testDiag("test_labels");
NTTableBuilderPtr builder = NTTable::createBuilder();
testOk(builder.get() != 0, "Got builder");
PVStructurePtr pvStructure = builder->
addColumn("column0", pvDouble)->
addColumn("column1", pvString)->
addColumn("column2", pvInt)->
createPVStructure();
testOk1(pvStructure.get() != 0);
if (!pvStructure)
return;
testOk1(NTTable::isCompatible(pvStructure)==true);
std::cout << *pvStructure << std::endl;
PVStringArrayPtr labels = pvStructure->getSubField<PVStringArray>("labels");
testOk1(labels.get() != 0);
testOk1(labels->getLength() == 3);
PVStringArray::const_svector l(labels->view());
testOk1(l[0] == "column0");
testOk1(l[1] == "column1");
testOk1(l[2] == "column2");
}
void test_wrap()
{
testDiag("test_wrap");
NTScalarArrayPtr nullPtr = NTScalarArray::wrap(PVStructurePtr());
testOk(nullPtr.get() == 0, "nullptr wrap");
nullPtr = NTScalarArray::wrap(
getPVDataCreate()->createPVStructure(
NTField::get()->createTimeStamp()
)
);
testOk(nullPtr.get() == 0, "wrong type wrap");
NTScalarArrayBuilderPtr builder = NTScalarArray::createBuilder();
testOk(builder.get() != 0, "Got builder");
PVStructurePtr pvStructure = builder->
value(pvDouble)->
createPVStructure();
testOk1(pvStructure.get() != 0);
if (!pvStructure)
return;
testOk1(NTScalarArray::isCompatible(pvStructure)==true);
NTScalarArrayPtr ptr = NTScalarArray::wrap(pvStructure);
testOk(ptr.get() != 0, "wrap OK");
ptr = NTScalarArray::wrapUnsafe(pvStructure);
testOk(ptr.get() != 0, "wrapUnsafe OK");
}
static PVRecordPtr createScalar(
string const & recordName,
ScalarType scalarType,
string const & properties)
{
PVStructurePtr pvStructure = getStandardPVField()->scalar(scalarType,properties);
PVRecordPtr pvRecord = PVRecord::create(recordName,pvStructure);
pvStructure.reset();
return pvRecord;
}
bool NTMultiChannel::isCompatible(PVStructurePtr const &pvStructure)
{
if(!pvStructure) return false;
PVUnionArrayPtr pvValue = pvStructure->getSubField<PVUnionArray>("value");
if(!pvValue) return false;
PVFieldPtr pvField = pvStructure->getSubField("descriptor");
if(pvField && !pvStructure->getSubField<PVString>("descriptor")) return false;
pvField = pvStructure->getSubField("alarm");
if(pvField && !ntField->isAlarm(pvField->getField())) return false;
pvField = pvStructure->getSubField("timeStamp");
if(pvField && !ntField->isTimeStamp(pvField->getField())) return false;
pvField = pvStructure->getSubField("severity");
if(pvField && !pvStructure->getSubField<PVIntArray>("severity")) return false;
pvField = pvStructure->getSubField("status");
if(pvField && !pvStructure->getSubField<PVIntArray>("status")) return false;
pvField = pvStructure->getSubField("message");
if(pvField && !pvStructure->getSubField<PVStringArray>("message")) return false;
pvField = pvStructure->getSubField("secondsPastEpoch");
if(pvField && !pvStructure->getSubField<PVLongArray>("secondsPastEpoch")) return false;
pvField = pvStructure->getSubField("nanoseconds");
if(pvField && !pvStructure->getSubField<PVIntArray>("nanoseconds")) return false;
pvField = pvStructure->getSubField("userTag");
if(pvField && !pvStructure->getSubField<PVIntArray>("userTag")) return false;
return true;
}
bool NTTable::isCompatible(PVStructurePtr const & pvStructure)
{
if(!pvStructure) return false;
PVFieldPtr pvField = pvStructure->getSubField("alarm");
if(pvField && !ntField->isAlarm(pvField->getField())) return false;
pvField = pvStructure->getSubField("timeStamp");
if(pvField && !ntField->isTimeStamp(pvField->getField())) return false;
PVStringArrayPtr pvLabel = pvStructure->getSubField<PVStringArray>("labels");
if(!pvLabel) return false;
return true;
}
static bool checkBitSetPVField(
PVFieldPtr const &pvField,BitSetPtr const &bitSet,int32 initialOffset)
{
int32 offset = initialOffset;
int32 nbits = static_cast<int32>(pvField->getNumberFields());
if(nbits==1) return bitSet->get(offset);
int32 nextSetBit = bitSet->nextSetBit(offset);
if(nextSetBit>=(offset+nbits)) return false;
if(nextSetBit<0) return false;
if(bitSet->get(offset)) {
if(nbits>1) {
for(int32 i=offset+1; i<offset+nbits; i++) bitSet->clear(i);
}
return true;
}
bool atLeastOneBitSet = false;
bool allBitsSet = true;
PVStructurePtr pvStructure = static_pointer_cast<PVStructure>(pvField);
offset = static_cast<int32>(pvStructure->getFieldOffset()) + 1;
while(offset<initialOffset + nbits) {
PVFieldPtr pvSubField = pvStructure->getSubField(offset);
int32 nbitsNow = static_cast<int32>(pvSubField->getNumberFields());
if(nbitsNow==1) {
if(bitSet->get(offset)) {
atLeastOneBitSet = true;
} else {
allBitsSet = false;
}
offset++;
} else {
bool result = checkBitSetPVField(pvSubField,bitSet,offset);
if(result) {
atLeastOneBitSet = true;
if(!bitSet->get(offset)) {
allBitsSet = false;
}
} else {
allBitsSet = false;
}
offset += static_cast<int32>(pvSubField->getNumberFields());
}
}
if(allBitsSet) {
if(nbits>1) {
for(int32 i=initialOffset+1; i<initialOffset+nbits; i++) {
bitSet->clear(i);
}
}
bitSet->set(initialOffset);
}
return atLeastOneBitSet;
}
void testDeserializeStructureAndCreatePVStructure()
{
buffer->clear();
registry->reset();
StructureConstPtr structureIn = getStructure("structure1");
serialize(structureIn,registry);
buffer->flip();
PVStructurePtr pvStructureOut = registry->deserializeStructureAndCreatePVStructure(buffer,control);
StructureConstPtr structureOut = pvStructureOut->getStructure();
assert(structureIn->getFieldName() == structureOut->getFieldName());
assert(structureIn->getType() == structureOut->getType());
delete pvStructureOut;
}
void PowerSupplyRecord::initPvt()
{
initPVRecord();
PVStructurePtr pvStructure = getPVStructure();
PVFieldPtr pvField;
pvField = pvStructure->getSubField("alarm");
pvAlarm.attach(pvField);
pvCurrent = pvStructure->getSubField<PVDouble>("current.value");
pvVoltage = pvStructure->getSubField<PVDouble>("voltage.value");
pvPower = pvStructure->getSubField<PVDouble>("power.value");
alarm.setMessage("bad voltage");
alarm.setSeverity(majorAlarm);
pvAlarm.set(alarm);
}
PVFieldPtr PVDataCreate::createPVField(PVFieldPtr const & fieldToClone)
{
switch(fieldToClone->getField()->getType()) {
case scalar:
{
PVScalarPtr pvScalar = static_pointer_cast<PVScalar>(fieldToClone);
return createPVScalar(pvScalar);
}
case scalarArray:
{
PVScalarArrayPtr pvScalarArray
= static_pointer_cast<PVScalarArray>(fieldToClone);
return createPVScalarArray(pvScalarArray);
}
case structure:
{
PVStructurePtr pvStructure
= static_pointer_cast<PVStructure>(fieldToClone);
StringArray const & fieldNames = pvStructure->getStructure()->getFieldNames();
PVFieldPtrArray const & pvFieldPtrArray = pvStructure->getPVFields();
return createPVStructure(fieldNames,pvFieldPtrArray);
}
case structureArray:
{
PVStructureArrayPtr from
= static_pointer_cast<PVStructureArray>(fieldToClone);
StructureArrayConstPtr structureArray = from->getStructureArray();
PVStructureArrayPtr to = createPVStructureArray(
structureArray);
to->copyUnchecked(*from);
return to;
}
case union_:
{
PVUnionPtr pvUnion
= static_pointer_cast<PVUnion>(fieldToClone);
return createPVUnion(pvUnion);
}
case unionArray:
{
PVUnionArrayPtr from
= static_pointer_cast<PVUnionArray>(fieldToClone);
UnionArrayConstPtr unionArray = from->getUnionArray();
PVUnionArrayPtr to = createPVUnionArray(unionArray);
to->copyUnchecked(*from);
return to;
}
}
throw std::logic_error("PVDataCreate::createPVField should never get here");
}
bool PVEnumerated::attach(PVFieldPtr const & pvField)
{
if(pvField->getField()->getType()!=structure) return false;
PVStructurePtr pvStructure = static_pointer_cast<PVStructure>(pvField);
pvIndex = pvStructure->getIntField("index");
if(pvIndex.get()==NULL) return false;
PVScalarArrayPtr pvScalarArray = pvStructure->getScalarArrayField(
"choices",pvString);
if(pvScalarArray.get()==NULL) {
pvIndex.reset();
return false;
}
pvChoices = static_pointer_cast<PVStringArray>(pvScalarArray);
return true;
}
bool ExampleLink::init()
{
initPVRecord();
PVStructurePtr pvStructure = getPVRecordStructure()->getPVStructure();
pvTimeStamp.attach(pvStructure->getSubField("timeStamp"));
pvAlarm.attach(pvStructure->getSubField("alarm"));
pvValue = pvStructure->getSubField<PVDoubleArray>("value");
if(!pvValue) {
return false;
}
ChannelProvider::shared_pointer provider =
getChannelProviderRegistry()->getProvider(providerName);
if(!provider) {
cout << getRecordName() << " provider "
<< providerName << " does not exist" << endl;
return false;
}
ChannelRequester::shared_pointer channelRequester =
dynamic_pointer_cast<ChannelRequester>(getPtrSelf());
channel = provider->createChannel(channelName,channelRequester);
event.wait();
if(!status.isOK()) {
cout << getRecordName() << " createChannel failed "
<< status.getMessage() << endl;
return false;
}
ChannelGetRequester::shared_pointer channelGetRequester =
dynamic_pointer_cast<ChannelGetRequester>(getPtrSelf());
PVStructurePtr pvRequest = CreateRequest::create()->createRequest(
"value,alarm,timeStamp");
channelGet = channel->createChannelGet(channelGetRequester,pvRequest);
event.wait();
if(!status.isOK()) {
cout << getRecordName() << " createChannelGet failed "
<< status.getMessage() << endl;
return false;
}
getPVValue = getPVStructure->getSubField<PVDoubleArray>("value");
if(!getPVValue) {
cout << getRecordName() << " get value not PVDoubleArray" << endl;
return false;
}
MonitorRequester::shared_pointer monitorRequester =
dynamic_pointer_cast<MonitorRequester>(getPtrSelf());
monitor = channel->createMonitor(monitorRequester,pvRequest);
return true;
}
PVStructurePtr MasarService::request(
PVStructurePtr const & pvArgument) throw (epics::pvAccess::RPCRequestException)
{
try{
assert(dslRdb.get() != NULL);
string functionName(pvArgument->getSubFieldT<PVString>("function")->get());
if(functionName.empty()) {
throw epics::pvAccess::RPCRequestException(
Status::STATUSTYPE_ERROR,"pvArgument has an unsupported function");
}
if(!NTNameValue::is_a(pvArgument->getStructure())) {
// support non NTNameValue Pair for some general purpose client, for example command line tools
const StringArray& fieldNames = pvArgument->getStructure()->getFieldNames();
size_t fieldcounts = fieldNames.size();
shared_vector<string> names (fieldcounts-1);
shared_vector<string> values (fieldcounts-1);
size_t counts = 0;
for (size_t i = 0; i < fieldcounts; i ++) {
if(fieldNames[i].compare("function")!=0) {
names[counts] = fieldNames[i];
values[counts] = pvArgument->getSubFieldT<PVString>(fieldNames[i])->get();
counts += 1;
}
}
PVStructurePtr result = dslRdb->request(functionName, freeze(names), freeze(values));
return result;
} else{
const shared_vector<const string> name = pvArgument->getSubFieldT<PVStringArray>("name")->view();
const shared_vector<const string> value = pvArgument->getSubFieldT<PVStringArray>("value")->view();
PVStructurePtr result = dslRdb->request(functionName, name, value);
return result;
}
}catch(epics::pvAccess::RPCRequestException&){
throw;
}catch(std::exception& e){
// since request(RPCRequestException) in our base class has a throw() specifier,
// if anything else is thrown we abort() :P
// so must translate all exceptions to RPCRequestException.
throw epics::pvAccess::RPCRequestException(Status::STATUSTYPE_ERROR,
std::string("request failed ") + e.what());
}
}
static void testRequest()
{
StringArray nullNames;
FieldConstPtrArray nullFields;
StringArray optionNames(1);
FieldConstPtrArray optionFields(1);
optionNames[0] = "process";
optionFields[0] = fieldCreate->createScalar(pvString);
StringArray recordNames(1);
FieldConstPtrArray recordFields(1);
recordNames[0] = "_options";
recordFields[0] = fieldCreate->createStructure(optionNames,optionFields);
StringArray fieldNames(2);
FieldConstPtrArray fieldFields(2);
fieldNames[0] = "alarm";
fieldFields[0] = fieldCreate->createStructure(nullNames,nullFields);
fieldNames[1] = "timeStamp";
fieldFields[1] = fieldCreate->createStructure(nullNames,nullFields);
StringArray topNames(2);
FieldConstPtrArray topFields(2);
topNames[0] = "record";
topFields[0] = fieldCreate->createStructure(recordNames,recordFields);
topNames[1] = "field";
topFields[1] = fieldCreate->createStructure(fieldNames,fieldFields);
StructureConstPtr topStructure = fieldCreate->createStructure(
topNames,topFields);
cout << *topStructure << endl;
PVStructurePtr pvTop = pvDataCreate->createPVStructure(topStructure);
cout << *pvTop << endl;
cout << *pvTop->getStructure() << endl;
PVStructurePtr xxx = pvTop->getSubField<PVStructure>("record");
cout << *xxx << endl;
xxx = pvTop->getSubField<PVStructure>("field");
cout << *xxx << endl;
PVStringPtr pvString = pvTop->getSubField<PVString>("record._options.process");
pvString->put("true");
cout << *pvTop << endl;
string subName("record._options.process");
PVFieldPtr pvField = pvTop->getSubField<PVString>(subName);
string fieldName = pvField->getFieldName();
string fullName = pvField->getFullName();
cout << "fieldName " << fieldName << " fullName " << fullName << endl;
testOk1(fieldName.compare("process")==0);
testOk1(fullName.compare(subName)==0);
}
void DbPvPut::put(PVStructurePtr const &pvStructure, BitSetPtr const & bitSet)
{
if(DbPvDebug::getLevel()>0) printf("dbPvPut::put()\n");
Lock lock(dataMutex);
this->pvStructure = pvStructure;
this->bitSet = bitSet;
PVFieldPtr pvField = pvStructure.get()->getPVFields()[0];
if(propertyMask&dbUtil->dbPutBit) {
Status status = dbUtil->putField(
channelPutRequester,propertyMask,dbAddr,pvField);
lock.unlock();
channelPutRequester->putDone(status,getPtrSelf());
return;
}
dbScanLock(dbAddr.precord);
Status status = dbUtil->put(
channelPutRequester, propertyMask, dbAddr, pvField);
if (process && !block) dbProcess(dbAddr.precord);
dbScanUnlock(dbAddr.precord);
lock.unlock();
if (block && process) {
epicsUInt8 value = 1;
pNotify.get()->pbuffer = &value;
dbPutNotify(pNotify.get());
} else {
channelPutRequester->putDone(status, getPtrSelf());
}
}
void DbPvPut::put(PVStructurePtr const &pvStructure, BitSetPtr const & bitSet)
{
if (DbPvDebug::getLevel() > 0) printf("dbPvPut::put()\n");
this->pvStructure = pvStructure;
this->bitSet = bitSet;
if (block && process) {
dbProcessNotify(pNotify.get());
return;
}
Lock lock(dataMutex);
PVFieldPtr pvField = pvStructure.get()->getPVFields()[0];
if (propertyMask & dbUtil->dbPutBit) {
status = dbUtil->putField(
channelPutRequester,
propertyMask,
dbPv->getDbChannel(),
pvField);
} else {
dbScanLock(dbChannelRecord(dbPv->getDbChannel()));
status = dbUtil->put(
channelPutRequester, propertyMask, dbPv->getDbChannel(), pvField);
if (process) dbProcess(dbChannelRecord(dbPv->getDbChannel()));
dbScanUnlock(dbChannelRecord(dbPv->getDbChannel()));
}
lock.unlock();
channelPutRequester->putDone(status, getPtrSelf());
}
size_t fromString(PVStructurePtr const & pvStructure, StringArray const & from, size_t fromStartIndex = 0)
{
// handle enum in a special way
if (pvStructure->getStructure()->getID() == "enum_t")
{
int32 index = -1;
PVInt::shared_pointer pvIndex = pvStructure->getSubField<PVInt>("index");
if (!pvIndex)
throw std::runtime_error("enum_t structure does not have 'int index' field");
PVStringArray::shared_pointer pvChoices = pvStructure->getSubField<PVStringArray>("choices");
if (!pvChoices)
throw std::runtime_error("enum_t structure does not have 'string choices[]' field");
PVStringArray::const_svector choices(pvChoices->view());
if (enumMode == AutoEnum || enumMode == StringEnum)
{
shared_vector<string>::const_iterator it = std::find(choices.begin(), choices.end(), from[fromStartIndex]);
if (it != choices.end())
index = static_cast<int32>(it - choices.begin());
else if (enumMode == StringEnum)
throw runtime_error("enum string value '" + from[fromStartIndex] + "' invalid");
}
if ((enumMode == AutoEnum && index == -1) || enumMode == NumberEnum)
{
istringstream iss(from[fromStartIndex]);
iss >> index;
// not fail and entire value is parsed (e.g. to detect 1.2 parsing to 1)
if (iss.fail() || !iss.eof())
throw runtime_error("enum value '" + from[fromStartIndex] + "' invalid");
if (index < 0 || index >= static_cast<int32>(choices.size()))
throw runtime_error("index '" + from[fromStartIndex] + "' out of bounds");
}
void ValueBuilder::child_struct::storeStruct(const ValueBuilder& self, const PVStructurePtr& val)
{
for(children_t::const_iterator it=self.children.begin(), end=self.children.end(); it!=end; ++it)
{
it->second->store(val->getSubFieldT(it->first));
}
}
ChannelPutGetLocalPtr ChannelPutGetLocal::create(
ChannelLocalPtr const &channelLocal,
ChannelPutGetRequester::shared_pointer const & channelPutGetRequester,
PVStructurePtr const & pvRequest,
PVRecordPtr const &pvRecord)
{
PVCopyPtr pvPutCopy = PVCopy::create(
pvRecord->getPVRecordStructure()->getPVStructure(),
pvRequest,
"putField");
PVCopyPtr pvGetCopy = PVCopy::create(
pvRecord->getPVRecordStructure()->getPVStructure(),
pvRequest,
"getField");
if(!pvPutCopy || !pvGetCopy) {
Status status(
Status::STATUSTYPE_ERROR,
"invalid pvRequest");
ChannelPutGet::shared_pointer channelPutGet;
channelPutGetRequester->channelPutGetConnect(
status,
channelPutGet,
nullStructure,
nullStructure);
ChannelPutGetLocalPtr localPutGet;
return localPutGet;
}
PVStructurePtr pvGetStructure = pvGetCopy->createPVStructure();
BitSetPtr getBitSet(new BitSet(pvGetStructure->getNumberFields()));
ChannelPutGetLocalPtr putGet(new ChannelPutGetLocal(
getProcess(pvRequest,true),
channelLocal,
channelPutGetRequester,
pvPutCopy,
pvGetCopy,
pvGetStructure,
getBitSet,
pvRecord));
if(pvRecord->getTraceLevel()>0)
{
cout << "ChannelPutGetLocal::create";
cout << " recordName " << pvRecord->getRecordName() << endl;
}
channelPutGetRequester->channelPutGetConnect(
Status::Ok, putGet, pvPutCopy->getStructure(),pvGetCopy->getStructure());
return putGet;
}
bool NTScalar::isCompatible(PVStructurePtr const & pvStructure)
{
if(!pvStructure) return false;
PVScalarPtr pvValue = pvStructure->getSubField<PVScalar>("value");
if(!pvValue) return false;
PVFieldPtr pvField = pvStructure->getSubField("descriptor");
if(pvField && !pvStructure->getSubField<PVString>("descriptor")) return false;
pvField = pvStructure->getSubField("alarm");
if(pvField && !ntField->isAlarm(pvField->getField())) return false;
pvField = pvStructure->getSubField("timeStamp");
if(pvField && !ntField->isTimeStamp(pvField->getField())) return false;
pvField = pvStructure->getSubField("display");
if(pvField && !ntField->isDisplay(pvField->getField())) return false;
pvField = pvStructure->getSubField("control");
if(pvField && !ntField->isControl(pvField->getField())) return false;
return true;
}
void PvaClientPutGet::getPutDone(
const Status& status,
ChannelPutGet::shared_pointer const & channelPutGet,
PVStructurePtr const & putPVStructure,
BitSetPtr const & putBitSet)
{
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
channelPutGetStatus = status;
if(status.isOK()) {
PVStructurePtr pvs = pvaClientPutData->getPVStructure();
pvs->copyUnchecked(*putPVStructure,*putBitSet);
BitSetPtr bs = pvaClientPutData->getChangedBitSet();
bs->clear();
*bs |= *putBitSet;
}
waitForPutGet.signal();
}
bool PVAlarm::attach(PVFieldPtr const & pvField)
{
if(pvField->getField()->getType()!=structure) return false;
PVStructurePtr pvStructure = static_pointer_cast<PVStructure>(pvField);
pvSeverity = pvStructure->getIntField("severity");
if(pvSeverity.get()==NULL) return false;
pvStatus = pvStructure->getIntField("status");
if(pvStatus.get()==NULL) {
pvSeverity.reset();
return false;
}
pvMessage = pvStructure->getStringField("message");
if(pvMessage.get()==NULL) {
pvSeverity.reset();
pvStatus.reset();
return false;
}
return true;
}
bool PowerSupply::init()
{
initPVRecord();
PVStructurePtr pvStructure = getPVStructure();
PVFieldPtr pvField;
bool result;
pvField = pvStructure->getSubField("timeStamp");
if(!pvField) {
cerr << "no timeStamp" << endl;
return false;
}
result = pvTimeStamp.attach(pvField);
if(!result) {
cerr << "no timeStamp" << endl;
return false;
}
pvField = pvStructure->getSubField("alarm");
if(!pvField) {
cerr << "no alarm" << endl;
return false;
}
result = pvAlarm.attach(pvField);
if(!result) {
cerr << "no alarm" << endl;
return false;
}
pvCurrent = pvStructure->getSubField<PVDouble>("current.value");
if(!pvCurrent) {
cerr << "no current\n";
return false;
}
pvVoltage = pvStructure->getSubField<PVDouble>("voltage.value");
if(!pvVoltage) {
cerr << "no current\n";
return false;
}
pvPower = pvStructure->getSubField<PVDouble>("power.value");
if(!pvPower) {
cerr << "no powert\n";
return false;
}
return true;
}
