StandardPVFieldPtr StandardPVField::getStandardPVField() { static StandardPVFieldPtr standardPVField; static Mutex mutex; Lock xx(mutex); if(standardPVField.get()==NULL) { standardPVField= StandardPVFieldPtr(new StandardPVField()); } return standardPVField; }
static void createRecords( PVDatabasePtr const &master, ScalarType scalarType, string const &recordNamePrefix, string const &properties) { string recordName = recordNamePrefix; PVStructurePtr pvStructure = standardPVField->scalar(scalarType,properties); PVRecordPtr pvRecord = PVRecord::create(recordName,pvStructure); bool result = master->addRecord(pvRecord); if(!result) cout<< "record " << recordName << " not added" << endl; recordName += "Array"; pvStructure = standardPVField->scalarArray(scalarType,properties); pvRecord = PVRecord::create(recordName,pvStructure); result = master->addRecord(pvRecord); }
static void scalarTest() { if(debug) { cout << endl << endl << "****scalarTest****" << endl; } PVStructurePtr pvMaster; string request; PVStructurePtr pvRequest; PVFieldPtr pvMasterField; PVCopyPtr pvCopy; string valueNameMaster; string valueNameCopy; StandardPVFieldPtr standardPVField = getStandardPVField(); pvMaster = standardPVField->scalar(pvDouble,"alarm,timeStamp,display"); valueNameMaster = request = "value"; CreateRequest::shared_pointer createRequest = CreateRequest::create(); pvRequest = createRequest->createRequest(request); if(debug) { cout << "request " << request << endl; } if(debug) { cout << "pvRequest\n" << *pvRequest << endl; } pvCopy = PVCopy::create(pvMaster,pvRequest,""); valueNameCopy = "value"; testPVScalar(valueNameMaster,valueNameCopy,pvMaster,pvCopy); request = ""; valueNameMaster = "value"; pvRequest = createRequest->createRequest(request); if(debug) { cout << "request " << request << endl; } if(debug) { cout << "pvRequest\n" << *pvRequest << endl; } pvCopy = PVCopy::create(pvMaster,pvRequest,""); valueNameCopy = "value"; testPVScalar(valueNameMaster,valueNameCopy,pvMaster,pvCopy); request = "alarm,timeStamp,value"; valueNameMaster = "value"; pvRequest = createRequest->createRequest(request); if(debug) { cout << "request " << request << endl; } if(debug) { cout << "pvRequest\n" << *pvRequest << endl; } pvCopy = PVCopy::create(pvMaster,pvRequest,""); valueNameCopy = "value"; testPVScalar(valueNameMaster,valueNameCopy,pvMaster,pvCopy); }
static void testCreatePVStructure() { PVStructurePtr pv0 = standardPVField->scalar( pvDouble,alarmTimeStampValueAlarm); PVScalarPtr pv1 = pvDataCreate->createPVScalar(pvString); PVFieldPtrArray pvFields; StringArray fieldNames; pvFields.reserve(2); fieldNames.reserve(2); fieldNames.push_back("value"); fieldNames.push_back("extra"); pvFields.push_back(pv0); pvFields.push_back(pv1); PVStructurePtr pvParent = pvDataCreate->createPVStructure( fieldNames,pvFields); std::cout << "testCreatePVStructure PASSED" << std::endl; }
static void testScalarArrayCommon(string /*fieldName*/,ScalarType stype) { PVStructurePtr pvStructure = standardPVField->scalarArray( stype,alarmTimeStamp); PVScalarArrayPtr scalarArray = pvStructure->getSubField<PVScalarArray>("value"); testOk1(scalarArray.get()!=0); if(stype==pvBoolean) { StringArray values(3); values[0] = "true"; values[1] = "false"; values[2] = "true"; convert->fromStringArray(scalarArray, 0,3,values,0); } else { StringArray values(3); values[0] = "0"; values[1] = "1"; values[2] = "2"; convert->fromStringArray(scalarArray, 0,3,values,0); } PVFieldPtr pvField = pvStructure->getSubField<PVInt>("alarm.status"); testOk1(pvField.get()!=0); }
static void test() { StandardPVFieldPtr standardPVField = getStandardPVField(); string properties; ScalarType scalarType; string recordName; properties = "alarm,timeStamp"; scalarType = pvDouble; recordName = "exampleDouble"; PVStructurePtr pvStructure; pvStructure = standardPVField->scalar(scalarType,properties); PVRecordPtr exampleRecord = PVRecord::create(recordName,pvStructure); exampleRecord->setTraceLevel(traceLevel); RecordClientPtr exampleRecordClient(RecordClient::create(exampleRecord)); ListenerPtr exampleListener(Listener::create(exampleRecord)); { exampleRecord->lock(); exampleRecord->process(); exampleRecord->unlock(); } if(debug) {cout << "processed exampleDouble " << endl; } exampleRecord->destroy(); recordName = "powerSupplyExample"; PowerSupplyPtr psr; pvStructure = createPowerSupply(); psr = PowerSupply::create("powerSupply",pvStructure); psr->setTraceLevel(traceLevel); RecordClientPtr psrRecordClient(RecordClient::create(psr)); ListenerPtr psrListener(Listener::create(psr)); testOk1(psr.get()!=0); if(!psr) { if(debug) {cout << "PowerSupplyRecordTest::create failed" << endl;} return; } double voltage,power,current; { psr->lock(); voltage = psr->getVoltage(); power = psr->getPower(); current = psr->getCurrent(); psr->unlock(); } if(debug ) { cout << "initial "; cout << " voltage " << voltage ; cout << " power " << power; cout << " current " << current; cout << endl; } testOk1(psr->getVoltage()==0.0); testOk1(psr->getPower()==0.0); testOk1(psr->getCurrent()==0.0); voltage = 1.0; power = 1.0; if(debug) { cout << "before put "; cout << " voltage " << voltage ; cout << " power " << power; cout << endl; } { psr->lock(); psr->put(power,voltage); psr->process(); psr->unlock(); } { psr->lock(); if(debug) { cout << "after put "; cout << " voltage " << psr->getVoltage() ; cout << " power " << psr->getPower(); cout << " current " << psr->getCurrent(); cout << endl; } psr->unlock(); } testOk1(psr->getVoltage()==1.0); testOk1(psr->getPower()==1.0); testOk1(psr->getCurrent()==1.0); psr->destroy(); }
static void testPVScalarWithProperties( string /*fieldName*/,ScalarType stype) { PVStructurePtr pvStructure; bool hasValueAlarm = false; bool hasBooleanAlarm = false; bool hasDisplayControl = false; switch(stype) { case pvBoolean: { pvStructure = standardPVField->scalar( stype,alarmTimeStampValueAlarm); hasBooleanAlarm = true; PVBooleanPtr pvField = pvStructure->getSubField<PVBoolean>("value"); pvField->put(true); break; } case pvByte: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVBytePtr pvField = pvStructure->getSubField<PVByte>("value"); pvField->put(127); break; } case pvShort: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVShortPtr pvField = pvStructure->getSubField<PVShort>("value"); pvField->put(32767); break; } case pvInt: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVIntPtr pvField = pvStructure->getSubField<PVInt>("value"); pvField->put((int32)0x80000000); break; } case pvLong: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVLongPtr pvField = pvStructure->getSubField<PVLong>("value"); int64 value = 0x80000000; value <<= 32; value |= 0xffffffff; pvField->put(value); break; } case pvUByte: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVUBytePtr pvField = pvStructure->getSubField<PVUByte>("value"); pvField->put(255); break; } case pvUShort: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVUShortPtr pvField = pvStructure->getSubField<PVUShort>("value"); pvField->put(65535); break; } case pvUInt: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVUIntPtr pvField = pvStructure->getSubField<PVUInt>("value"); pvField->put((uint32)0x80000000); break; } case pvULong: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVULongPtr pvField = pvStructure->getSubField<PVULong>("value"); int64 value = 0x80000000; value <<= 32; value |= 0xffffffff; pvField->put(value); break; } case pvFloat: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVFloatPtr pvField = pvStructure->getSubField<PVFloat>("value"); pvField->put(1.123e8); break; } case pvDouble: { pvStructure = standardPVField->scalar( stype,allProperties); hasValueAlarm = true; hasDisplayControl = true; PVDoublePtr pvField = pvStructure->getSubField<PVDouble>("value"); pvField->put(1.123e35); break; } case pvString: { pvStructure = standardPVField->scalar( stype,alarmTimeStamp); PVStringPtr pvField = pvStructure->getSubField<PVString>("value"); pvField->put(string("this is a string")); break; } } PVLongPtr seconds = pvStructure->getSubField<PVLong>( string("timeStamp.secondsPastEpoch")); testOk1(seconds.get()!=0); seconds->put(123456789); PVIntPtr nano = pvStructure->getSubField<PVInt>(string("timeStamp.nanoseconds")); testOk1(nano.get()!=0); nano->put(1000000); PVIntPtr severity = pvStructure->getSubField<PVInt>(string("alarm.severity")); testOk1(severity.get()!=0); severity->put(2); PVStringPtr message = pvStructure->getSubField<PVString>(string("alarm.message")); testOk1(message.get()!=0); message->put(string("messageForAlarm")); if(hasDisplayControl) { PVStringPtr desc = pvStructure->getSubField<PVString>( string("display.description")); testOk1(desc.get()!=0); desc->put(string("this is a description")); PVStringPtr format = pvStructure->getSubField<PVString>( string("display.format")); testOk1(format.get()!=0); format->put(string("f10.2")); PVStringPtr units = pvStructure->getSubField<PVString>( string("display.units")); testOk1(units.get()!=0); units->put(string("SomeUnits")); PVDoublePtr limit = pvStructure->getSubField<PVDouble>( string("display.limitLow")); testOk1(limit.get()!=0); limit->put(0.0); limit = pvStructure->getSubField<PVDouble>( string("display.limitHigh")); testOk1(limit.get()!=0); limit->put(10.0); limit = pvStructure->getSubField<PVDouble>( string("control.limitLow")); testOk1(limit.get()!=0); limit->put(1.0); limit = pvStructure->getSubField<PVDouble>( string("control.limitHigh")); testOk1(limit.get()!=0); limit->put(9.0); } if(hasValueAlarm) { PVBooleanPtr pvBoolean = pvStructure->getSubField<PVBoolean>("valueAlarm.active"); pvBoolean->put(true); PVScalarPtr pvtemp = pvStructure->getSubField<PVScalar>("valueAlarm.lowAlarmLimit"); testOk1(pvtemp.get()!=0); convert->fromDouble(pvtemp,1.0); pvtemp = pvStructure->getSubField<PVScalar>("valueAlarm.highAlarmLimit"); testOk1(pvtemp.get()!=0); convert->fromDouble(pvtemp,9.0); severity = pvStructure->getSubField<PVInt>( string("valueAlarm.lowAlarmSeverity")); testOk1(severity.get()!=0); severity->put(2); severity = pvStructure->getSubField<PVInt>( string("valueAlarm.highAlarmSeverity")); testOk1(severity.get()!=0); severity->put(2); PVBooleanPtr active = pvStructure->getSubField<PVBoolean>( string("valueAlarm.active")); testOk1(active.get()!=0); active->put(true); } if(hasBooleanAlarm) { PVBooleanPtr pvBoolean = pvStructure->getSubField<PVBoolean>("valueAlarm.active"); pvBoolean->put(true); severity = pvStructure->getSubField<PVInt>( string("valueAlarm.falseSeverity")); testOk1(severity.get()!=0); severity->put(0); severity = pvStructure->getSubField<PVInt>( string("valueAlarm.trueSeverity")); testOk1(severity.get()!=0); severity->put(2); severity = pvStructure->getSubField<PVInt>( string("valueAlarm.changeStateSeverity")); testOk1(severity.get()!=0); severity->put(1); } }
static void testCopy() { TEST_COPY(PVBoolean, 1); TEST_COPY(PVByte, 12); TEST_COPY(PVShort, 128); TEST_COPY(PVInt, 128000); TEST_COPY(PVLong, 128000000); TEST_COPY(PVUByte, 12); TEST_COPY(PVUShort, 128); TEST_COPY(PVUInt, 128000); TEST_COPY(PVULong, 128000000); TEST_COPY(PVFloat, 12.8); TEST_COPY(PVDouble, 8.12); TEST_COPY(PVString, "jikes"); int32 testValue = 128; // PVStructure test PVStructurePtr pvStructure = standardPVField->scalar(pvInt, alarmTimeStampValueAlarm); pvStructure->getSubField<PVInt>("value")->put(testValue); PVTimeStamp timeStamp; timeStamp.attach(pvStructure->getSubField<PVStructure>("timeStamp")); TimeStamp current; current.getCurrent(); timeStamp.set(current); PVStructurePtr pvStructureCopy = standardPVField->scalar(pvInt, alarmTimeStampValueAlarm); pvStructureCopy->copy(*pvStructure); testOk(*pvStructure == *pvStructureCopy, "PVStructure copy"); PVStructurePtr pvStructureCopy2 = standardPVField->scalar(pvInt, alarmTimeStampValueAlarm); pvStructureCopy2->copyUnchecked(*pvStructure); testOk(*pvStructure == *pvStructureCopy2, "PVStructure copyUnchecked"); BitSet mask(pvStructure->getNumberFields()); PVStructurePtr pvStructureCopy3 = standardPVField->scalar(pvInt, alarmTimeStampValueAlarm); PVStructurePtr pvStructureCopy4 = standardPVField->scalar(pvInt, alarmTimeStampValueAlarm); pvStructureCopy3->copyUnchecked(*pvStructure, mask); testOk(*pvStructureCopy3 == *pvStructureCopy4, "PVStructure copyUnchecked w/ cleared mask"); mask.set(pvStructure->getSubField<PVInt>("value")->getFieldOffset()); pvStructureCopy3->copyUnchecked(*pvStructure, mask); pvStructureCopy4->getSubField<PVInt>("value")->put(testValue); testOk(*pvStructureCopy3 == *pvStructureCopy4, "PVStructure copyUnchecked w/ value mask only"); mask.set(pvStructure->getSubField<PVStructure>("timeStamp")->getFieldOffset()); PVStructurePtr pvStructureCopy5 = standardPVField->scalar(pvInt, alarmTimeStampValueAlarm); pvStructureCopy5->copyUnchecked(*pvStructure, mask); testOk(*pvStructure == *pvStructureCopy5, "PVStructure copyUnchecked w/ value+timeStamp mask"); UnionConstPtr _union = fieldCreate->createFieldBuilder()-> add("doubleValue", pvDouble)-> add("intValue", pvInt)-> add("timeStamp",standardField->timeStamp())-> createUnion(); PVUnionPtr pvUnion = pvDataCreate->createPVUnion(_union); PVUnionPtr pvUnion2 = pvDataCreate->createPVUnion(_union); pvUnion2->copy(*pvUnion); testOk(*pvUnion == *pvUnion2, "null PVUnion copy"); pvUnion->select<PVInt>("intValue")->put(123); pvUnion2->copy(*pvUnion); testOk(*pvUnion == *pvUnion2, "PVUnion scalar copy, to null PVUnion"); pvUnion->select("doubleValue"); pvUnion2->copy(*pvUnion); testOk(*pvUnion == *pvUnion2, "PVUnion scalar copy, to different type PVUnion"); pvUnion->select<PVStructure>("timeStamp")->copy( *pvStructure->getSubField<PVStructure>("timeStamp") ); pvUnion2->copy(*pvUnion); testOk(*pvUnion == *pvUnion2, "PVUnion PVStructure copy, to different type PVUnion"); }
void ExampleDatabase::create() { PVDatabasePtr master = PVDatabase::getMaster(); PVRecordPtr pvRecord; string recordName; bool result(false); recordName = "traceRecordPGRPC"; pvRecord = TraceRecord::create(recordName); result = master->addRecord(pvRecord); if(!result) cout<< "record " << recordName << " not added" << endl; string properties; properties = "alarm,timeStamp"; createRecords(master,pvByte,"byte01",properties); createRecords(master,pvShort,"short01",properties); createRecords(master,pvLong,"long01",properties); createRecords(master,pvUByte,"ubyte01",properties); createRecords(master,pvUInt,"uint01",properties); createRecords(master,pvUShort,"ushort01",properties); createRecords(master,pvULong,"ulong01",properties); createRecords(master,pvFloat,"float01",properties); StringArray choices(2); choices[0] = "zero"; choices[1] = "one"; master->addRecord(PVRecord::create( "exampleEnum",standardPVField->enumerated(choices,properties))); createRecords(master,pvBoolean,"exampleBoolean",properties); createRecords(master,pvByte,"exampleByte",properties); createRecords(master,pvShort,"exampleShort",properties); createRecords(master,pvInt,"exampleInt",properties); createRecords(master,pvLong,"exampleLong",properties); createRecords(master,pvFloat,"exampleFloat",properties); createRecords(master,pvDouble,"exampleDouble",properties); createRecords(master,pvDouble,"exampleDouble01",properties); createRecords(master,pvDouble,"exampleDouble02",properties); createRecords(master,pvDouble,"exampleDouble03",properties); createRecords(master,pvDouble,"exampleDouble04",properties); createRecords(master,pvDouble,"exampleDouble05",properties); createRecords(master,pvString,"exampleString",properties); createStructureArrayRecord(master,"exampleStructureArray"); createRegularUnionRecord(master,"exampleRegularUnion"); createVariantUnionRecord(master,"exampleVariantUnion"); createRegularUnionArrayRecord(master,"exampleRegularUnionArray"); createVariantUnionArrayRecord(master,"exampleVariantUnionArray"); createDumbPowerSupplyRecord(master,"exampleDumbPowerSupply"); recordName = "examplePowerSupply"; PVStructurePtr pvStructure = createPowerSupply(); PowerSupplyPtr psr = PowerSupply::create(recordName,pvStructure); if(!psr) { cout << "PowerSupply::create failed" << endl; } else { result = master->addRecord(psr); if(!result) cout<< "record " << recordName << " not added" << endl; } recordName = "exampleHello"; result = master->addRecord(ExampleHello::create(recordName)); if(!result) cout<< "record " << recordName << " not added" << endl; RPCServer::shared_pointer server(new RPCServer()); server->registerService("exampleHelloRPC",ExampleHelloRPC::create()); }