void NTNDArrayRecord::setAttributes() { // Get the attribute field PVStructureArrayPtr attributeField = ndarray->getAttribute(); // Create a shared vector or reuse PVStructureArray::svector attributes(attributeField->reuse()); attributes.reserve(1); // Create an attribute for the Color Mode // name: ColorMode // value: variant union stores a PVInt with value 0 // descriptor: "Color mode" // source: "" // sourceType = 0 PVStructurePtr attribute = getPVDataCreate()->createPVStructure(attributeField->getStructureArray()->getStructure()); NTNDArrayAttributePtr ntattribute = NTNDArrayAttribute::wrap(attribute); ntattribute->getName()->put("ColorMode"); PVInt::shared_pointer pvColorMode = getPVDataCreate()->createPVScalar<PVInt>(); pvColorMode->put(0); ntattribute->getValue()->set(pvColorMode); ntattribute->getDescriptor()->put("Color mode"); ntattribute->getSourceType()->put(0); ntattribute->getSource()->put(""); attributes.push_back(attribute); // Replace the attribute fields stored attributeField->replace(freeze(attributes)); }
size_t fromString(PVStructureArrayPtr const &pv, StringArray const & from, size_t fromStartIndex = 0) { int processed = 0; size_t fromValueCount = from.size(); // first get count if (fromStartIndex >= fromValueCount) throw std::runtime_error("not enough of values"); size_t numberOfStructures; istringstream iss(from[fromStartIndex]); iss >> numberOfStructures; // not fail and entire value is parsed (e.g. to detect 1.2 parsing to 1) if (iss.fail() || !iss.eof()) throw runtime_error("failed to parse element count value (uint) of field '" + pv->getFieldName() + "' from string value '" + from[fromStartIndex] + "'"); fromStartIndex++; processed++; PVStructureArray::svector pvStructures; pvStructures.reserve(numberOfStructures); PVDataCreatePtr pvDataCreate = getPVDataCreate(); for (size_t i = 0; i < numberOfStructures; ++i) { PVStructurePtr pvStructure = pvDataCreate->createPVStructure(pv->getStructureArray()->getStructure()); size_t count = fromString(pvStructure, from, fromStartIndex); processed += count; fromStartIndex += count; pvStructures.push_back(pvStructure); } pv->replace(freeze(pvStructures)); return processed; }
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)); }
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"); }
void testPVNTField() { testDiag("testPVNTField"); StringArray choices; choices.resize(3); choices[0] = "one"; choices[1] = "two"; choices[2] = "three"; PVStructurePtr pvStructure = PVStructurePtr( pvntField->createEnumerated(choices)); cout << *pvStructure << endl; testOk1(ntField->isEnumerated(pvStructure->getStructure())); pvStructure = PVStructurePtr(pvntField->createTimeStamp()); cout << *pvStructure << endl; testOk1(ntField->isTimeStamp(pvStructure->getStructure())); pvStructure = PVStructurePtr(pvntField->createAlarm()); cout << *pvStructure << endl; testOk1(ntField->isAlarm(pvStructure->getStructure())); pvStructure = PVStructurePtr(pvntField->createDisplay()); cout << *pvStructure << endl; testOk1(ntField->isDisplay(pvStructure->getStructure())); pvStructure = PVStructurePtr(pvDataCreate->createPVStructure(standardField->doubleAlarm())); cout << *pvStructure << endl; testOk1(ntField->isAlarmLimit(pvStructure->getStructure())); PVStructureArrayPtr pvStructureArray = PVStructureArrayPtr( pvntField->createEnumeratedArray()); cout << *pvStructure << endl; cout << *pvStructureArray->getStructureArray()->getStructure(); pvStructureArray = PVStructureArrayPtr( pvntField->createTimeStampArray()); cout << *pvStructure << endl; cout << *pvStructureArray->getStructureArray()->getStructure(); pvStructureArray = PVStructureArrayPtr( pvntField->createAlarmArray()); cout << *pvStructure << endl; cout << *pvStructureArray->getStructureArray()->getStructure(); }
int64 NTNDArray::getExpectedUncompressedSize() { int64 size = 0; PVStructureArrayPtr pvDim = getDimension(); if (pvDim->getLength() != 0) { PVStructureArray::const_svector data = pvDim->view(); size = getValueTypeSize(); for (PVStructureArray::const_svector::const_iterator it = data.begin(); it != data.end(); ++it ) { PVStructurePtr dim = *it; size *= dim->getSubField<PVInt>("size")->get(); } } return size; }
void ExampleServiceRPC::request( ChannelRPCRequester::shared_pointer const & channelRPCRequester, epics::pvData::PVStructure::shared_pointer const & pvArgument) { String buffer; PVStringPtr pvfunction = pvArgument->getStringField("function"); PVStringArrayPtr pvnames = static_pointer_cast<PVStringArray> (pvArgument->getScalarArrayField("names",pvString)); PVStringArrayPtr pvvalues = static_pointer_cast<PVStringArray> (pvArgument->getScalarArrayField("values",pvString)); buffer += "pvArgument "; bool is = true; if(pvfunction==0) is = false; if(pvnames==0) is = false; if(pvvalues==0) is = false; if(is) { buffer += "is a NTNameValue\n"; } else { buffer += "is not a NTNameValue\n "; } pvArgument->toString(&buffer); printf("%s\n",buffer.c_str()); StandardFieldPtr standardField = getStandardField(); StandardPVFieldPtr standardPVField = getStandardPVField(); FieldCreatePtr fieldCreate = getFieldCreate(); PVDataCreatePtr pvDataCreate = getPVDataCreate(); size_t n = 5; FieldConstPtrArray fields; StringArray names; fields.reserve(n); names.reserve(n); names.push_back("alarm"); names.push_back("timeStamp"); names.push_back("label"); names.push_back("position"); names.push_back("alarms"); StructureConstPtr xxx = standardField->alarm(); printf("xxx %p\n",xxx.get()); fields.push_back(standardField->alarm()); fields.push_back(standardField->timeStamp()); fields.push_back(fieldCreate->createScalarArray(pvString)); fields.push_back(fieldCreate->createScalarArray(pvDouble)); fields.push_back(fieldCreate->createStructureArray(standardField->alarm())); StructureConstPtr structure = fieldCreate->createStructure(names,fields); printf("structure %p\n",structure.get()); buffer.clear(); structure->toString(&buffer); printf("structure\n%s\n",buffer.c_str()); PVStructurePtr pvStructure = pvDataCreate->createPVStructure(structure); PVTimeStamp pvTimeStamp; TimeStamp timeStamp; pvTimeStamp.attach(pvStructure->getStructureField("timeStamp")); timeStamp.getCurrent(); pvTimeStamp.set(timeStamp); StringArray label; label.reserve(2); for(int i=0; i<2; i++) { label.push_back(names[i+3]); } PVStringArrayPtr pvLabel = static_pointer_cast<PVStringArray> (pvStructure->getScalarArrayField("label",pvString)); pvLabel->put(0,2,label,0); PVDoubleArrayPtr pvPositions = static_pointer_cast<PVDoubleArray> (pvStructure->getScalarArrayField("position",pvDouble)); double positions[2]; positions[0] = 1.0; positions[1] = 2.0; pvPositions->put(0,2,positions,0); PVStructureArrayPtr pvAlarms = static_pointer_cast<PVStructureArray> (pvStructure->getStructureArrayField("alarms")); PVAlarm pvAlarm; Alarm alarm; PVStructurePtrArray palarms; size_t na=2; palarms.reserve(na); for(size_t i=0; i<na; i++) { palarms.push_back(pvDataCreate->createPVStructure(standardField->alarm())); } for(size_t i=0; i<na; i++) { pvAlarm.attach(palarms[i]); alarm.setMessage("test"); alarm.setSeverity(majorAlarm); alarm.setStatus(clientStatus); pvAlarm.set(alarm); } pvAlarms->put(0,2,palarms,0); String labels[2]; labels[0] = pvPositions->getFieldName(); labels[1] = pvAlarms->getFieldName(); pvLabel->put(0,2,labels,0); buffer.erase(); pvStructure->toString(&buffer); printf("%s\n",buffer.c_str()); channelRPCRequester->requestDone(Status::Ok,pvStructure); }