static bool isCompatible(StructureConstPtr const &structure) { if(!structure.get()) return false; if (structure->getID() != "dimension_t") return false; ScalarConstPtr scalarField = structure->getField<Scalar>("size"); if (scalarField.get() == 0 || scalarField->getScalarType() != pvInt) return false; scalarField = structure->getField<Scalar>("offset"); if (scalarField.get() == 0 || scalarField->getScalarType() != pvInt) return false; scalarField = structure->getField<Scalar>("fullSize"); if (scalarField.get() == 0 || scalarField->getScalarType() != pvInt) return false; scalarField = structure->getField<Scalar>("binning"); if (scalarField.get() == 0 || scalarField->getScalarType() != pvInt) return false; scalarField = structure->getField<Scalar>("reverse"); if (scalarField.get() == 0 || scalarField->getScalarType() != pvBoolean) return false; return true; }
bool NTHistogram::isCompatible(StructureConstPtr const &structure) { if(!structure.get()) return false; ScalarArrayConstPtr rangesField = structure->getField<ScalarArray>("ranges"); if(!rangesField.get() || rangesField->getElementType() != pvDouble) return false; ScalarArrayConstPtr valueField = structure->getField<ScalarArray>("value"); if(!valueField.get()) return false; ScalarType scalarType = valueField->getElementType(); if (scalarType != pvShort && scalarType != pvInt && scalarType != pvLong) return false; FieldConstPtr field = structure->getField("descriptor"); if(field) { ScalarConstPtr descriptorField = structure->getField<Scalar>("descriptor"); if (!descriptorField.get() || descriptorField->getScalarType() != pvString) return false; } field = structure->getField("alarm"); if (field.get() && !ntField->isAlarm(field)) return false; field = structure->getField("timeStamp"); if (field.get() && !ntField->isTimeStamp(field)) return false; return true; }
bool NTNameValue::isCompatible(StructureConstPtr const & structure) { if (structure.get() == 0) return false; ScalarArrayConstPtr nameField = structure->getField<ScalarArray>("name"); if (nameField.get() == 0 || nameField->getElementType() != pvString) return false; ScalarArrayConstPtr valueField = structure->getField<ScalarArray>("value"); if (valueField.get() == 0) return false; FieldConstPtr field = structure->getField("descriptor"); if (field.get()) { ScalarConstPtr descriptorField = structure->getField<Scalar>("descriptor"); if (!descriptorField || descriptorField->getScalarType() != pvString) return false; } NTFieldPtr ntField = NTField::get(); field = structure->getField("alarm"); if (field && !ntField->isAlarm(field)) return false; field = structure->getField("timeStamp"); if (field && !ntField->isTimeStamp(field)) return false; return true; }
PVScalarPtr PVDataCreate::createPVScalar(ScalarConstPtr const & scalar) { ScalarType scalarType = scalar->getScalarType(); switch(scalarType) { case pvBoolean: return PVScalarPtr(new BasePVBoolean(scalar)); case pvByte: return PVScalarPtr(new BasePVByte(scalar)); case pvShort: return PVScalarPtr(new BasePVShort(scalar)); case pvInt: return PVScalarPtr(new BasePVInt(scalar)); case pvLong: return PVScalarPtr(new BasePVLong(scalar)); case pvUByte: return PVScalarPtr(new BasePVUByte(scalar)); case pvUShort: return PVScalarPtr(new BasePVUShort(scalar)); case pvUInt: return PVScalarPtr(new BasePVUInt(scalar)); case pvULong: return PVScalarPtr(new BasePVULong(scalar)); case pvFloat: return PVScalarPtr(new BasePVFloat(scalar)); case pvDouble: return PVScalarPtr(new BasePVDouble(scalar)); case pvString: return PVScalarPtr(new BasePVString(scalar)); } throw std::logic_error("PVDataCreate::createPVScalar should never get here"); }
static void setValue(PVUnionPtr const &pvUnion, double value) { UnionConstPtr u = pvUnion->getUnion(); FieldConstPtr field = u->getField(0); Type type = field->getType(); if(type==scalar) { ScalarConstPtr scalar = static_pointer_cast<const Scalar>(field); ScalarType scalarType = scalar->getScalarType(); if(scalarType==pvDouble) { PVDoublePtr pvValue = static_pointer_cast<PVDouble>( pvDataCreate->createPVScalar(pvDouble)); pvValue->put(value); pvUnion->set(0,pvValue); return; } if(scalarType==pvString) { PVStringPtr pvValue = static_pointer_cast<PVString>( pvDataCreate->createPVScalar(pvString)); stringstream ss; ss << "value" << value; pvValue->put(ss.str()); pvUnion->set(0,pvValue); return; } throw std::runtime_error("only pvDouble and pvString are supported"); } if(type==scalarArray) { ScalarArrayConstPtr scalarArray = static_pointer_cast<const ScalarArray>(field); ScalarType scalarType = scalarArray->getElementType(); if(scalarType==pvDouble) { size_t num = 5; PVDoubleArrayPtr pvValue = static_pointer_cast<PVDoubleArray>( pvDataCreate->createPVScalarArray(pvDouble)); shared_vector<double> data(num); for(size_t i=0; i<num; ++i) data[i] = value +i; pvValue->replace(freeze(data)); pvUnion->set(0,pvValue); return; } if(scalarType==pvString) { size_t num = 5; PVStringArrayPtr pvValue = static_pointer_cast<PVStringArray>( pvDataCreate->createPVScalarArray(pvString)); shared_vector<string> data(num); for(size_t i=0; i<num; ++i) { stringstream ss; ss << "value" << value << i; data[i] = ss.str(); } pvValue->replace(freeze(data)); pvUnion->set(0,pvValue); return; } throw std::runtime_error("only pvDouble and pvString are supported"); } throw std::runtime_error("only scalar and scalarArray fields are supported"); }
static bool isCompatible(StructureConstPtr const &structure) { if(!structure.get()) return false; if (structure->getID() != "codec_t") return false; ScalarConstPtr scalarField = structure->getField<Scalar>("name"); if (scalarField.get() == 0 || scalarField->getScalarType() != pvString) return false; UnionConstPtr paramField = structure->getField<Union>("parameters"); if (paramField.get() == 0 || !paramField->isVariant()) return false; return true; }
void test_builder() { testDiag("test_builder"); NTNDArrayAttributeBuilderPtr builder = NTNDArrayAttribute::createBuilder(); testOk(builder.get() != 0, "Got builder"); StructureConstPtr structure = builder-> addTags()-> addAlarm()-> addTimeStamp()-> add("extra",fieldCreate->createScalar(pvString)) -> createStructure(); testOk1(structure.get() != 0); if (!structure) return; testOk1(NTNDArrayAttribute::is_a(structure)); testOk1(structure->getID() == NTNDArrayAttribute::URI); testOk1(structure->getNumberFields() == 9); testOk1(structure->getField("name").get() != 0); testOk1(structure->getField("value").get() != 0); testOk1(structure->getField("tags").get() != 0); testOk1(structure->getField("descriptor").get() != 0); testOk1(structure->getField("alarm").get() != 0); testOk1(structure->getField("timeStamp").get() != 0); testOk1(structure->getField("sourceType").get() != 0); testOk1(structure->getField("source").get() != 0); ScalarConstPtr nameField = structure->getField<Scalar>("name"); testOk(nameField.get() != 0 && nameField->getScalarType() == pvString, "name is string"); UnionConstPtr valueField = structure->getField<Union>("value"); testOk(valueField.get() != 0, "value is enum"); ScalarArrayConstPtr tagsField = structure->getField<ScalarArray>("tags"); testOk(tagsField.get() != 0 && tagsField->getElementType() == pvString, "tags is string[]"); std::cout << *structure << std::endl; }
PVStringPtr PVStructure::getStringField(String const &fieldName) { PVFieldPtr pvField = findSubField(fieldName,this); if(pvField.get()==NULL) { String message("fieldName "); message += fieldName + " does not exist"; this->message(message, errorMessage); return nullPVString; } if(pvField->getField()->getType()==scalar) { ScalarConstPtr pscalar = static_pointer_cast<const Scalar>( pvField->getField()); if(pscalar->getScalarType()==pvString) { return std::tr1::static_pointer_cast<PVString>(pvField); } } String message("fieldName "); message += fieldName + " does not have type string "; this->message(message, errorMessage); return nullPVString; }
bool NTMatrix::isCompatible(StructureConstPtr const & structure) { if (structure.get() == 0) return false; ScalarArrayConstPtr valueField = structure->getField<ScalarArray>("value"); if (valueField.get() == 0 || valueField->getElementType() != pvDouble) return false; FieldConstPtr field = structure->getField("dim"); if (field.get()) { ScalarArrayConstPtr dimField = structure->getField<ScalarArray>("dim"); if (dimField.get() == 0 || dimField->getElementType() != pvInt) return false; } field = structure->getField("descriptor"); if (field.get()) { ScalarConstPtr descriptorField = structure->getField<Scalar>("descriptor"); if (!descriptorField.get() || descriptorField->getScalarType() != pvString) return false; } NTFieldPtr ntField = NTField::get(); field = structure->getField("alarm"); if (field.get() && !ntField->isAlarm(field)) return false; field = structure->getField("timeStamp"); if (field.get() && !ntField->isTimeStamp(field)) return false; field = structure->getField("display"); if (field.get() && !ntField->isDisplay(field)) return false; return true; }
bool NTScalar::isCompatible(StructureConstPtr const &structure) { if (structure.get() == 0) return false; ScalarConstPtr valueField = structure->getField<Scalar>("value"); if (valueField.get() == 0) return false; FieldConstPtr field = structure->getField("descriptor"); if (field.get()) { ScalarConstPtr descriptorField = structure->getField<Scalar>("descriptor"); if (!descriptorField.get() || descriptorField->getScalarType() != pvString) return false; } NTFieldPtr ntField = NTField::get(); field = structure->getField("alarm"); if (field.get() && !ntField->isAlarm(field)) return false; field = structure->getField("timeStamp"); if (field.get() && !ntField->isTimeStamp(field)) return false; field = structure->getField("display"); if (field.get() && !ntField->isDisplay(field)) return false; field = structure->getField("control"); if (field.get() && !ntField->isControl(field)) return false; return true; }
void MonitorRequesterImpl::ParseScalar(QString fieldName, PVScalarPtr const & pvs, knobData* kPtr) { QString thisFieldName = QString::fromStdString(pvs->getFieldName()); //qDebug() << "ParseScalar -- field/subfield" << fieldName << thisFieldName; ScalarConstPtr scalar = pvs->getScalar(); ScalarType scalarType = scalar->getScalarType(); switch(scalarType) { case pvBoolean: { PVBooleanPtr data = static_pointer_cast<PVBoolean>(pvs); if(thisFieldName.contains("value")) { kPtr->edata.fieldtype = caINT; kPtr->edata.ivalue = (int)data->get(); } } break; case pvByte: { PVBytePtr data = static_pointer_cast<PVByte>(pvs); if(thisFieldName.contains("value")) { kPtr->edata.fieldtype = caCHAR; kPtr->edata.ivalue = (int)data->get(); } } break; case pvShort: { PVShortPtr data = static_pointer_cast<PVShort>(pvs); if(thisFieldName.contains("value")) { kPtr->edata.fieldtype = caINT; kPtr->edata.rvalue = data->get(); kPtr->edata.ivalue = (int)data->get(); } } break; case pvInt: { PVIntPtr data = static_pointer_cast<PVInt>(pvs); if(fieldName.contains("alarm") && thisFieldName.contains("severity")) { kPtr->edata.severity =(int) data->get(); } else if(fieldName.contains("alarm") && thisFieldName.contains("status")) { kPtr->edata.status = (int) data->get(); } if(thisFieldName.contains("value")) { kPtr->edata.fieldtype = caINT; kPtr->edata.rvalue = data->get(); kPtr->edata.ivalue = (int)data->get(); } } break; case pvLong: { PVLongPtr data = static_pointer_cast<PVLong>(pvs); if(thisFieldName.contains("value")) { kPtr->edata.fieldtype = caLONG; kPtr->edata.rvalue = data->get(); kPtr->edata.ivalue = (int64)data->get(); } } break; case pvFloat: { PVFloatPtr data = static_pointer_cast<PVFloat>(pvs); if(thisFieldName.contains("value")) { kPtr->edata.fieldtype = caFLOAT; kPtr->edata.rvalue = data->get(); } } break; case pvDouble: { PVDoublePtr data = static_pointer_cast<PVDouble>(pvs); if(fieldName.contains("display") && thisFieldName.contains("limitLow")) { kPtr->edata.lower_disp_limit = data->get(); } else if(fieldName.contains("display") && thisFieldName.contains("limitHigh")) { kPtr->edata.upper_disp_limit = data->get(); } else if(fieldName.contains("control") && thisFieldName.contains("limitLow")) { kPtr->edata.lower_ctrl_limit = data->get(); } else if(fieldName.contains("control") && thisFieldName.contains("limitHigh")) { kPtr->edata.upper_ctrl_limit = data->get(); } else if(fieldName.contains("valueAlarm") && thisFieldName.contains("lowAlarmLimit")) { kPtr->edata.lower_alarm_limit = data->get(); } else if(fieldName.contains("valueAlarm") && thisFieldName.contains("highAlarmLimit")) { kPtr->edata.upper_alarm_limit = data->get(); } else if(fieldName.contains("valueAlarm") && thisFieldName.contains("lowWarningLimit")) { kPtr->edata.lower_warning_limit = data->get(); } else if(fieldName.contains("valueAlarm") && thisFieldName.contains("highWarningLimit")) { kPtr->edata.upper_warning_limit = data->get(); // fill value and type } else if(thisFieldName.contains("value")) { kPtr->edata.precision = 3; // for the time beeing, set to 3 kPtr->edata.fieldtype = caDOUBLE; kPtr->edata.rvalue = data->get(); } } break; case pvString: { PVStringPtr data = static_pointer_cast<PVString>(pvs); // fill units if(fieldName.contains("display") && thisFieldName.contains("units")) { strcpy(kPtr->edata.units, data->get().c_str()); } else if(fieldName.contains("display") && thisFieldName.contains("description")) { } else if(fieldName.contains("display") && thisFieldName.contains("format")) { // should use now precision // fill value and type } else if(thisFieldName.contains("value")) { qDebug() << "String :" << data->get().c_str(); } } break; default: qDebug() << "(unknown ScalarType)" << endl; } }
bool NTNDArray::isCompatible(StructureConstPtr const &structure) { if(!structure.get()) return false; UnionConstPtr valueField = structure->getField<Union>("value"); if(!NTValueType::isCompatible(valueField)) return false; StructureConstPtr codecField = structure->getField<Structure>("codec"); if(!NTCodec::isCompatible(codecField)) return false; ScalarConstPtr compressedSizeField = structure->getField<Scalar>("compressedSize"); if (compressedSizeField.get() == 0) return false; if (compressedSizeField->getScalarType() != pvLong) return false; ScalarConstPtr uncompressedSizeField = structure->getField<Scalar>("uncompressedSize"); if (uncompressedSizeField.get() == 0) return false; if (uncompressedSizeField->getScalarType() != pvLong) return false; StructureArrayConstPtr dimensionField = structure->getField<StructureArray>("dimension"); if (dimensionField.get() == 0) return false; StructureConstPtr dimElementStruc = dimensionField->getStructure(); if(!NTDimension::isCompatible(dimElementStruc)) return false; NTFieldPtr ntField = NTField::get(); StructureConstPtr dataTimeStampField = structure->getField<Structure>( "dataTimeStamp"); if (dataTimeStampField.get() == 0 || !ntField->isTimeStamp(dataTimeStampField)) return false; ScalarConstPtr uniqueIdField = structure->getField<Scalar>("uniqueId"); if (uniqueIdField.get() == 0) return false; if (uniqueIdField->getScalarType() != pvInt) return false; StructureArrayConstPtr attributeField = structure->getField<StructureArray>( "attribute"); StructureConstPtr attributeElementStruc = attributeField->getStructure(); if (!NTNDArrayAttribute::isCompatible(attributeElementStruc)) return false; FieldConstPtr field = structure->getField("descriptor"); if (field.get()) { ScalarConstPtr descriptorField = structure->getField<Scalar>("descriptor"); if (!descriptorField.get() || descriptorField->getScalarType() != pvString) return false; } field = structure->getField("alarm"); if (field.get() && !ntField->isAlarm(field)) return false; field = structure->getField("timeStamp"); if (field.get() && !ntField->isTimeStamp(field)) return false; field = structure->getField("display"); if (field.get() && !ntField->isDisplay(field)) return false; return true; }
StructureConstPtr StandardField::createProperties(String id,FieldConstPtr field,String properties) { bool gotAlarm = false; bool gotTimeStamp = false; bool gotDisplay = false; bool gotControl = false; bool gotValueAlarm = false; int numProp = 0; if(properties.find("alarm")!=String::npos) { gotAlarm = true; numProp++; } if(properties.find("timeStamp")!=String::npos) { gotTimeStamp = true; numProp++; } if(properties.find("display")!=String::npos) { gotDisplay = true; numProp++; } if(properties.find("control")!=String::npos) { gotControl = true; numProp++; } if(properties.find("valueAlarm")!=String::npos) { gotValueAlarm = true; numProp++; } StructureConstPtr valueAlarm; Type type= field->getType(); while(gotValueAlarm) { if(type==epics::pvData::scalar || type==epics::pvData::scalarArray) { ScalarType scalarType = (type==epics::pvData::scalar) ? static_pointer_cast<const Scalar>(field)->getScalarType() : static_pointer_cast<const ScalarArray>(field)->getElementType(); switch(scalarType) { case pvBoolean: valueAlarm = booleanAlarmField; break; case pvByte: valueAlarm = byteAlarmField; break; case pvShort: valueAlarm = shortAlarmField; break; case pvInt: valueAlarm = intAlarmField; break; case pvLong: valueAlarm = longAlarmField; break; case pvUByte: valueAlarm = ubyteAlarmField; break; case pvUShort: valueAlarm = ushortAlarmField; break; case pvUInt: valueAlarm = uintAlarmField; break; case pvULong: valueAlarm = ulongAlarmField; break; case pvFloat: valueAlarm = floatAlarmField; break; case pvDouble: valueAlarm = doubleAlarmField; break; case pvString: throw std::logic_error(String("valueAlarm property not supported for pvString")); } break; } if(type==structure) { StructureConstPtr structurePtr = static_pointer_cast<const Structure>(field); StringArray names = structurePtr->getFieldNames(); if(names.size()==2) { FieldConstPtrArray fields = structurePtr->getFields(); FieldConstPtr first = fields[0]; FieldConstPtr second = fields[1]; String nameFirst = names[0]; String nameSecond = names[1]; int compareFirst = nameFirst.compare("index"); int compareSecond = nameSecond.compare("choices"); if(compareFirst==0 && compareSecond==0) { if(first->getType()==epics::pvData::scalar && second->getType()==epics::pvData::scalarArray) { ScalarConstPtr scalarFirst = static_pointer_cast<const Scalar>(first); ScalarArrayConstPtr scalarArraySecond = static_pointer_cast<const ScalarArray>(second); if(scalarFirst->getScalarType()==pvInt && scalarArraySecond->getElementType()==pvString) { valueAlarm = enumeratedAlarmField; break; } } } } } throw std::logic_error(String("valueAlarm property for illegal type")); } size_t numFields = numProp+1; FieldConstPtrArray fields(numFields); StringArray names(numFields); int next = 0; names[0] = "value"; fields[next++] = field; if(gotAlarm) { names[next] = "alarm"; fields[next++] = alarmField; } if(gotTimeStamp) { names[next] = "timeStamp"; fields[next++] = timeStampField; } if(gotDisplay) { names[next] = "display"; fields[next++] = displayField; } if(gotControl) { names[next] = "control"; fields[next++] = controlField; } if(gotValueAlarm) { names[next] = "valueAlarm"; fields[next++] = valueAlarm; } return fieldCreate->createStructure(id,names,fields); }